o [h3e@sddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z m Z mZmZmZmZmZmZmZmZddlmZmZddlmZmZmZmZmZmZm Z ddl!m"Z"m#Z#dd l$m%Z%dd l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-dd l.m/Z/dd l m0Z0m1Z1m2Z2m3Z3dd l4m5Z5m6Z6ddl7m8Z8m9Z9ddl.m:Z:ddl;mGdddZ?e?Z@  d!d"dd ZAdS)#) annotationsN) TracebackType) Any AsyncIteratorCallable GeneratorListOptionalSequenceTupleTypecast)Headers HeadersLike)InvalidHandshake InvalidHeaderInvalidMessageInvalidStatusCodeNegotiationErrorRedirectHandshake SecurityError)ClientExtensionFactory Extension) enable_client_permessage_deflate)build_authorization_basicbuild_extension build_hostbuild_subprotocolparse_extensionparse_subprotocolvalidate_subprotocols) USER_AGENT)ExtensionHeader LoggerLikeOrigin Subprotocol) WebSocketURI parse_uri) build_requestcheck_response) read_response)WebSocketCommonProtocol)connect unix_connectWebSocketClientProtocolcs|eZdZdZdZdZddddddd+fddZd,ddZd-ddZe d.d!d"Z e d/d%d&Z    d0d1d)d*Z Z S)2r0a WebSocket client connection. :class:`WebSocketClientProtocol` provides :meth:`recv` and :meth:`send` coroutines for receiving and sending messages. It supports asynchronous iteration to receive incoming 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). It raises a :exc:`~websockets.exceptions.ConnectionClosedError` when the connection is closed with any other code. See :func:`connect` for the documentation of ``logger``, ``origin``, ``extensions``, ``subprotocols``, and ``extra_headers``. See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``, ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``. TclientN)loggerorigin extensions subprotocols extra_headersr2Optional[LoggerLike]r3Optional[Origin]r4*Optional[Sequence[ClientExtensionFactory]]r5Optional[Sequence[Subprotocol]]r6Optional[HeadersLike]kwargsrreturnNonec sD|dur td}tjdd|i|||_||_||_||_dS)Nwebsockets.clientr2)logging getLoggersuper__init__r3available_extensionsavailable_subprotocolsr6)selfr2r3r4r5r6r< __class__r@/home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/websockets/legacy/client.pyrDTs  z WebSocketClientProtocol.__init__pathstrheadersrcCsn||_||_|jr!|jd||D] \}}|jd||qd|d}|t|7}|j|dS)zF Write request line and headers to the HTTP request. z> GET %s HTTP/1.1z> %s: %szGET z HTTP/1.1 N) rKrequest_headersdebugr2 raw_itemsrL transportwriteencode)rGrKrMkeyvaluerequestr@r@rJwrite_http_requestfs  z*WebSocketClientProtocol.write_http_requestTuple[int, Headers]c sz t|jIdH\}}}Wntjyty'}ztd|d}~ww|jrD|jd|||D] \}}|jd||q7||_ ||j fS)a< Read status line and headers from the HTTP response. If the response contains a body, it may be read from ``self.reader`` after this coroutine returns. Raises: InvalidMessage: if the HTTP message is malformed or isn't an HTTP/1.1 GET response. Nz%did not receive a valid HTTP responsez< HTTP/1.1 %d %sz< %s: %s) r,readerasyncioCancelledError ExceptionrrOr2rPresponse_headers)rG status_codereasonrMexcrTrUr@r@rJread_http_responsezs   z*WebSocketClientProtocol.read_http_responserEList[Extension]c Csg}|d}|rO|durtdtdd|Dg}|D]1\}}|D] }|j|kr+q#z|||}Wn ty<Yq#w||n td|d|q|S)a/ Handle the Sec-WebSocket-Extensions HTTP response header. Check that each extension is supported, as well as its parameters. Return the list of accepted extensions. Raise :exc:`~websockets.exceptions.InvalidHandshake` to abort the connection. :rfc:`6455` leaves the rules up to the specification of each :extension. To provide this level of flexibility, for each extension accepted by the server, we check for a match with each extension available in the client configuration. If no match is found, an exception is raised. If several variants of the same extension are accepted by the server, it may be configured several times, which won't make sense in general. Extensions must implement their own requirements. For this purpose, the list of previously accepted extensions is provided. Other requirements, for example related to mandatory extensions or the order of extensions, may be implemented by overriding this method. Sec-WebSocket-ExtensionsNzno extensions supportedcSg|]}t|qSr@)r.0 header_valuer@r@rJ z>WebSocketClientProtocol.process_extensions..zUnsupported extension: name = z , params = )get_allrsumnameZprocess_response_paramsrappend) rMrEZaccepted_extensions header_valuesparsed_header_valuesrlZresponse_paramsextension_factory extensionr@r@rJprocess_extensionss<      z*WebSocketClientProtocol.process_extensionsrFOptional[Subprotocol]cCs|d}|d}|r<|durtdtdd|Dg}t|dkr-d|}td||d }||vr.r)z, zmultiple subprotocols: rzunsupported subprotocol: )rjrrklenjoinr)rMrF subprotocolrnror5r@r@rJprocess_subprotocols   z+WebSocketClientProtocol.process_subprotocolwsurir'c s.t}t|j|j|j|d<|jrt|j|d<|dur!||d<t|}|dur6tdd|D}||d<|durBt |} | |d<|j durM| |j | d t ||j||IdH\} } | d vrud | vrotd t| d | d kr~t| | t| ||| ||_|| ||_|dS) a6 Perform the client side of the opening handshake. Args: wsuri: URI of the WebSocket server. origin: value of the ``Origin`` header. available_extensions: list of supported extensions, in order in which they should be tried. available_subprotocols: list of supported subprotocols, in order of decreasing preference. extra_headers: arbitrary HTTP headers to add to the request. Raises: InvalidHandshake: if the handshake fails. Host AuthorizationNr%cSsg|] }|j|fqSr@)rlZget_request_params)rfrpr@r@rJrh0s z5WebSocketClientProtocol.handshake..rcrtz User-Agent)i-i.i/i3i4ZLocatione)rrhostportsecureZ user_inforr*rrr6update setdefaultr"rW resource_namerarrrr+rrr4rxrwZconnection_open) rGryr3rErFr6rNrTZextensions_headerZprotocol_headerr^r]r@r@rJ handshakesN       z!WebSocketClientProtocol.handshake)r2r7r3r8r4r9r5r:r6r;r<rr=r>)rKrLrMrr=r>)r=rX)rMrrEr9r=rb)rMrrFr:r=rs)NNNN) ryr'r3r8rEr9rFr:r6r;r=r>)__name__ __module__ __qualname____doc__Z is_clientZsiderDrWra staticmethodrrrxr __classcell__r@r@rHrJr07s*   K &r0c@seZdZdZdZdddddddddddddddd dFd)d*ZdGd+d,Zd-Zd.Zd/Z d0Z dHd2d3Z dId5d6Z dJd=d>Z dKd@dAZdIdBdCZdIdDdEZeZdS)LConnectaw Connect to the WebSocket server at ``uri``. Awaiting :func:`connect` yields a :class:`WebSocketClientProtocol` which can then be used to send and receive messages. :func:`connect` can be used as a asynchronous context manager:: async with websockets.connect(...) as websocket: ... The connection is closed automatically when exiting the context. :func:`connect` can be used as an infinite asynchronous iterator to reconnect automatically on errors:: async for websocket in websockets.connect(...): try: ... except websockets.ConnectionClosed: continue The connection is closed automatically after each iteration of the loop. If an error occurs while establishing the connection, :func:`connect` retries with exponential backoff. The backoff delay starts at three seconds and increases up to one minute. If an error occurs in the body of the loop, you can handle the exception and :func:`connect` will reconnect with the next iteration; or you can let the exception bubble up and break out of the loop. This lets you decide which errors trigger a reconnection and which errors are fatal. Args: uri: URI of the WebSocket server. create_protocol: factory for the :class:`asyncio.Protocol` managing the connection; defaults to :class:`WebSocketClientProtocol`; may be set to a wrapper or a subclass to customize connection handling. logger: logger for this connection; defaults to ``logging.getLogger("websockets.client")``; see the :doc:`logging guide <../topics/logging>` for details. compression: shortcut that enables the "permessage-deflate" extension by default; may be set to :obj:`None` to disable compression; see the :doc:`compression guide <../topics/compression>` for details. origin: value of the ``Origin`` header. This is useful when connecting to a server that validates the ``Origin`` header to defend against Cross-Site WebSocket Hijacking attacks. extensions: list of supported extensions, in order in which they should be tried. subprotocols: list of supported subprotocols, in order of decreasing preference. extra_headers: arbitrary HTTP headers to add to the request. open_timeout: timeout for opening the connection in seconds; :obj:`None` to disable the timeout See :class:`~websockets.legacy.protocol.WebSocketCommonProtocol` for the documentation of ``ping_interval``, ``ping_timeout``, ``close_timeout``, ``max_size``, ``max_queue``, ``read_limit``, and ``write_limit``. Any other keyword arguments are passed the event loop's :meth:`~asyncio.loop.create_connection` method. For example: * You can set ``ssl`` to a :class:`~ssl.SSLContext` to enforce TLS settings. When connecting to a ``wss://`` URI, if ``ssl`` isn't provided, a TLS context is created with :func:`~ssl.create_default_context`. * You can set ``host`` and ``port`` to connect to a different host and port from those found in ``uri``. This only changes the destination of the TCP connection. The host name from ``uri`` is still used in the TLS handshake for secure connections and in the ``Host`` header. Returns: WebSocketClientProtocol: WebSocket connection. Raises: InvalidURI: if ``uri`` isn't a valid WebSocket URI. InvalidHandshake: if the opening handshake fails. ~asyncio.TimeoutError: if the opening handshake times out. Ndeflatei i)create_protocolr2 compressionr3r4r5r6 open_timeout ping_interval ping_timeout close_timeoutmax_size max_queue read_limit write_limiturirLr2Optional[Callable[[Any], WebSocketClientProtocol]]r2r7r Optional[str]r3r8r4r9r5r:r6r;rOptional[float]rrrr Optional[int]rrintrr<rr=r>cKsB|dd}|dur d}ntdt| dur|} |dd}|dur&t}ntdt|dur2|}|dd}|dd}|durGt}n|}td tt|}|jr]| d d n | d durht d |d krqt |}n |dur|t d||durt |tj|fid|d|d|d|d|d| d| d| d| d|d|d|d|jd|jd|jd|d|}|ddr|dd}tj|j||fi|}n,| d dur|j|j}}nd!\}}|d|}|d|}tj|j|||fi|}| |_|durtd"}||_||_||_||_dS)#Ntimeoutrzrename timeout to close_timeoutklasszrename klass to create_protocol legacy_recvFloopzremove loop argumentsslTzQconnect() received a ssl argument for a ws:// URI, use a wss:// URI to enable TLSrzunsupported compression: r2r3r4r5r6rrrrrrrr}r~runixrKsock)NNr?)popwarningswarnDeprecationWarningr0rZZget_event_loopr(rrget ValueErrorrr! functoolspartialr}r~Zcreate_unix_connectioncreate_connectionrrArBr2_create_connection_uri_wsuri)rGrrr2rr3r4r5r6rrrrrrrrr<rrr_looprryfactoryrKrr}r~r@r@rJrDs                      zConnect.__init__cCs|j}|j}tj||}t|}|jr|jstd|j|jko&|j |j k}|s[|j j d}t j |jg|j Rit|j|j|j d}t j |j jg||j|j fRi|j j|_ ||_||_dS)Nzredirect from WSS to WSr)r}r~)rrurllibparseurljoinr(rrr}r~rargsrrfuncdictkeywords)rGrZold_uriZ old_wsuriZnew_uriZ new_wsuriZ same_originrr@r@rJhandle_redirect&s4    zConnect.handle_redirectgQ?gN@gS?&AsyncIterator[WebSocketClientProtocol]c Cs|j} z!|4IdH}|VWdIdHn 1IdHs wYWnOtjy/tyu||jkrSt|j}|jjd|ddt|IdHn|jjdt |ddtt |IdH||j }t ||j }Yqw|j}q)NTz.! connect failed; reconnecting in %.1f seconds)exc_infoz.! connect failed again; retrying in %d seconds) BACKOFF_MINrZr[r\randomBACKOFF_INITIALr2infosleeprBACKOFF_FACTORmin BACKOFF_MAX)rGZ backoff_delayprotocolZ initial_delayr@r@rJ __aiter__Rs>(    zConnect.__aiter__r0cs |IdHSNr@rGr@r@rJ __aenter__xs zConnect.__aenter__exc_typeOptional[Type[BaseException]] exc_valueOptional[BaseException] tracebackOptional[TracebackType]cs|jIdHdSr)rclose)rGrrrr@r@rJ __aexit__{szConnect.__aexit__-Generator[Any, None, WebSocketClientProtocol]cCs |Sr)__await_impl_timeout__ __await__rr@r@rJrs zConnect.__await__cst||jIdHSr)rZwait_for__await_impl__rrr@r@rJrszConnect.__await_impl_timeout__c st|jD]X}|IdH\}}tt|}z0z|j|j|j|j|j |j dIdHWnt y>| | IdHw||_|WSty^}z ||jWYd}~qd}~wwtd)N)r3rErFr6ztoo many redirects)rangeMAX_REDIRECTS_ALLOWEDrr r0rrr3rErFr6r\Zfail_connectionZ wait_closedrrrrr)rGZ redirectsrQrr`r@r@rJrs2   zConnect.__await_impl__)$rrLrrr2r7rrr3r8r4r9r5r:r6r;rrrrrrrrrrrrrrrrr<rr=r>)rrLr=r>)r=r)r=r0)rrrrrrr=r>)r=r)rrrrrrDrrrrrrrrrrr__iter__r@r@r@rJrWs>T x'  &   rws://localhost/rKrrrLr<rr=cKstd||dd|S)a Similar to :func:`connect`, but for connecting to a Unix socket. This function builds upon the event loop's :meth:`~asyncio.loop.create_unix_connection` method. It is only available on Unix. It's mainly useful for debugging servers listening on Unix sockets. Args: path: file system path to the Unix socket. uri: URI of the WebSocket server; the host is used in the TLS handshake for secure connections and in the ``Host`` header. T)rrKrNr@)r.)rKrr<r@r@rJr/sr/)Nr)rKrrrLr<rr=r)B __future__rrZrrAr urllib.parserrtypesrtypingrrrrrr r r r r Zdatastructuresrr exceptionsrrrrrrrr4rrZextensions.permessage_deflaterrMrrrrrr r!httpr"r#r$r%r&rr'r(rr*r+r,rr-__all__r0rr.r/r@r@r@rJs>  0 $ $   "V