xjzddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z m Z mZddlmZddlmZmZmZmZddlmZmZmZddlmZmZdd lmZmZm Z m!Z!m"Z"dd l#m$Z$dd l%m&Z&dd l'm(Z(dd l)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5ddlm6Z6m7Z7m8Z8m9Z9ddl:m;Z;mZ>gdZ?e@ejABddZCGdde>ZDGddZE d6d7d#ZF dd$lGmHZHdd%lIm0ZJeHjKeHjKeHjLeHjLd&ZMd'd(d'd(d&ZNd8d.ZOn#eP$rd8d/ZOYnwxYwGd0d1ejQZRdd2d9d5ZSdS):) annotationsN) AsyncIterator GeneratorSequence) TracebackType)AnyCallableLiteralcast)ClientProtocolbackoffprocess_exception)Headers HeadersLike)InvalidProxyMessageInvalidProxyStatus InvalidStatus ProxyError SecurityError)ClientExtensionFactory) enable_client_permessage_deflate)validate_subprotocols) USER_AGENTResponse) CONNECTINGEvent)Proxy get_proxy parse_proxyprepare_connect_request) StreamReader) LoggerLikeOriginPathLike Subprotocol) WebSocketURI parse_uri) Connection)connect unix_connectClientConnectionWEBSOCKETS_MAX_REDIRECTS10cLeZdZdZdddddddfdZdefddZdfd ZxZS) r-a :mod:`asyncio` implementation of a WebSocket client connection. :class:`ClientConnection` provides :meth:`recv` and :meth:`send` coroutines 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:`connect`. Args: protocol: Sans-I/O connection.   ping_interval ping_timeout close_timeout max_queue write_limitprotocolr r6 float | Noner7r8r9*int | None | tuple[int | None, int | None]r:int | tuple[int, int | None]returnNonec|t|||||||j|_dS)Nr5)super__init__loop create_future response_rcvd)selfr;r6r7r8r9r: __class__s JC:\Projects\Historical\venv\Lib\site-packages\websockets/asyncio/client.pyrCzClientConnection.__init__As\ %  '%'#    4893J3J3L3LNadditional_headersHeadersLike | Noneuser_agent_header str | Nonec(K|j|_||jj|| |jjd||t4d{V|j|jdddd{Vn#1d{VswxYwYtj |j |j gtj d{V|jj |jjdS)z1 Perform the opening handshake. Nz User-Agent)expected_state) return_when)r;r+requestheadersupdate setdefault send_contextr send_requestasynciowaitrFconnection_lost_waiterFIRST_COMPLETED handshake_exc)rGrKrMs rI handshakezClientConnection.handshakeVs},,..  ) L ' '(: ; ; ;  ( L + +L:K L L L$$J$?? 5 5 5 5 5 5 5 5 M & &t| 4 4 4 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5 5l  !< =/           = & 2-- - 3 2s B77 CCeventrc|j:t|tsJ||_|jddSt |dS)z. Process one incoming event. N)response isinstancerrF set_resultrB process_event)rGr^rHs rIrczClientConnection.process_eventssg = eX.. . ..!DM   ) )$ / / / / / GG ! !% ( ( ( ( (rJ)r;r r6r<r7r<r8r<r9r=r:r>r?r@)rKrLrMrNr?r@)r^rr?r@) __name__ __module__ __qualname____doc__rCrr]rc __classcell__)rHs@rIr-r-(s8')%'&(@B49MMMMMMMM.26(2.....: ) ) ) ) ) ) ) ) ) )rJr-czeZdZdZdddddededdddeddd ddd dDd0ZdEd2ZdFd6Z dEd7Z dGd9Z dEd:Z dHdAZ dIdCZdS)Jr+u' Connect to the WebSocket server at ``uri``. :func:`connect` should be treated as an asynchronous context manager yielding a :class:`ClientConnection`, which can then receive and send messages:: from websockets.asyncio.client import connect async with connect(...) as websocket: ... The connection is closed automatically when exiting the context. :func:`connect` can also be treated as an infinite asynchronous iterator to reconnect automatically on errors:: async for websocket in connect(...): try: ... except websockets.exceptions.ConnectionClosed: continue If the connection fails with a transient error, it is retried with exponential backoff. If it fails with a fatal error, the exception is raised, breaking out of the loop. The connection is closed automatically after each iteration of the loop. :func:`connect` can be awaited directly:: websocket = await connect(...) In that case, you're responsible for closing the connection with :meth:`ClientConnection.close` when no longer needed. Args: uri: URI of the WebSocket server. origin: Value of the ``Origin`` header, for servers that require it. 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. 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. additional_headers: Arbitrary HTTP headers to add to the handshake request. user_agent_header: Value of the ``User-Agent`` request header. It defaults to ``"Python/x.y.z websockets/X.Y"``. Setting it to :obj:`None` removes the header. proxy: If a proxy is configured, it is used by default. Set ``proxy`` to :obj:`None` to disable the proxy or to the address of a proxy to override the system configuration. See the :doc:`proxy docs <../../topics/proxies>` for details. process_exception: When reconnecting automatically, tell whether an error is transient or fatal. The default behavior is defined by :func:`~websockets.client.process_exception`. Refer to its documentation for details. open_timeout: Timeout for opening the connection 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 the connection in seconds. :obj:`None` disables the timeout. reconnect_delays: Delays in seconds between reconnection attempts. Default is exponential backoff with 5s jitter, capped at 60s. 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 client. It defaults to ``logging.getLogger("websockets.client")``. See the :doc:`logging guide <../../topics/logging>` for details. create_connection: Factory for the :class:`ClientConnection` 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_connection` method. For example: * You can set ``sock`` to provide a preexisting TCP socket. You may call :func:`socket.create_connection` (not to be confused with the event loop's :meth:`~asyncio.loop.create_connection` method) to create a suitable client socket and customize it. * 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 ``server_hostname`` to override the host name from ``uri`` in the TLS handshake. * You can configure ``ssl_handshake_timeout`` and ``ssl_shutdown_timeout``. * 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. When using a proxy: * Prefix keyword arguments with ``proxy_`` for configuring TLS between the client and an HTTPS proxy: ``proxy_ssl``, ``proxy_server_hostname``, ``proxy_ssl_handshake_timeout``, and ``proxy_ssl_shutdown_timeout``. * Use the standard keyword arguments for configuring TLS between the proxy and the WebSocket server: ``ssl``, ``server_hostname``, ``ssl_handshake_timeout``, and ``ssl_shutdown_timeout``. * Other keyword arguments are used only for connecting to the proxy. Raises: InvalidURI: If ``uri`` isn't a valid WebSocket URI. InvalidProxy: If ``proxy`` isn't a valid proxy. OSError: If the TCP connection fails. InvalidHandshake: If the opening handshake fails. TimeoutError: If the opening handshake times out. NdeflateTr2r1ir3r4)origin extensions subprotocols compressionrKrMproxyr open_timeoutr6r7r8reconnect_delaysmax_sizer9r:loggercreate_connectionuristrrk Origin | Nonerl'Sequence[ClientExtensionFactory] | NonermSequence[Subprotocol] | NonernrNrKrLrMrostr | Literal[True] | Noner'Callable[[Exception], Exception | None]rpr<r6r7r8rqCallable[[], Generator[float]]rrr=r9r:r>rsLoggerLike | Nonerttype[ClientConnection] | Nonekwargsrr?r@c  ||_t||_|jjs$|dt dt |dkrtn|t d|tj dt||_ ||_ ||_ | |_| |_||_|_||_d  f d }||_dS) Nsslz-ssl argument is incompatible with a ws:// URIrjzunsupported compression: zwebsockets.clientrur'r?r-cT t|  }|  }|S)N)rkrlrmrrrsr5)r )rur; connectionr8rtrlrsr9rrrkr6r7rmr:s rIfactoryz!connect.__init__..factoryCs\%%)! H+*+)+#' J rJ)rur'r?r-)rur(ws_urisecureget ValueErrorrrlogging getLoggerr-rKrMrorrprqrscreate_connection_kwargsr)rGrurkrlrmrnrKrMrorrpr6r7r8rqrrr9r:rsrtrrs ``` ``` ````` rIrCzconnect.__init__sY>nn {! Nfjj&7&7&CLMM M  # !, / / / ) # #9*EEJJ  $FFFGG G >&':;;F  $ 0 "4!2 !2( 0 (.%                , rJr-cKtj}j}j}|ddrd}|dd}|durt j}dfd }jjrZ| d d|d td | d jj | ddr|j |fi|d{V\}}|S|t|}|jdd d krLt!|j| ddd{V}|j|fd|i|d{V\}}|S|jdddkrt|ii}} } | D]N\} } | d s| d kr| || <&| dr| | | dd<I| | | <O|jdkr;| d d| d tdn$| d tdt)|jfdji| d{V} |}| || d d}|durt/j}||j| ||fi|d{V}|J|} || |St7d|d@| djj | djj|j|fi|d{V\}}|S)zFOpen a TCP or Unix connection to the server, possibly through a proxy.unixFNsockTr?r-c8jSN)rrrGsrIrz,connect.open_tcp_connection..factoryhs<< ,, ,rJrz*ssl=None is incompatible with a wss:// URIserver_hostnamesocks local_addr)rhttpproxy_httpsz5proxy_ssl=None is incompatible with an https:// proxyz8proxy_ssl argument is incompatible with an http:// proxyrMz&parse_proxy returned unsupported proxyhostportr?r-)rXget_running_looprcopyrorrrrrUrrpopcreate_unix_connectionr schemeconnect_socks_proxyrtitems startswithconnect_http_proxyrM set_protocol ssl_modulecreate_default_context start_tlsconnection_madeAssertionErrorr)rGrDrror_r proxy_parsedr all_kwargs proxy_kwargskeyvalue transportr new_transports` rIopen_tcp_connectionzconnect.open_tcp_connection[s')).3355  ::fe $ $ E ::f   )E D==dk**E - - - - - - ;  C   eT * * *zz%  ( !MNNN   /1A B B B ::fe $ $ "=$"=g"P"P"P"PPPPPPPMAz   &u--L"2A2&'110 K%zz,== '=d&<'''''!!!!!! : "!$RaR(F22392r&L ","2"2"4"422JC~~e,,27H0H0H&+s 11205 SW--,1 S))&'11 ++E4888#''..6(S7 $''..:(V#5 K##'+&<## ## %WYY &&z222jj--$;;$;==C?*8$.!:s++6<++%%%%%%M)444 -I**9555!!%%MNNNzz&!!)!!&$+*:;;;!!&$+*:;;;"8$"8"K"KF"K"KKKKKKKMAz rJexc ExceptionException | strcxt|tr|jjdvrd|jjvs|S|j}t j|j |jjd}t|}|j dtd|dS|jr|jstd|S|j|jks |j|jks|j|jkr|j dd rtd |d S|j d |j d td |dS|jBt'dt'|jD|_|S)z Determine whether a connection error is a redirect that can be followed. Return the new URI if it's a valid redirect. Else, return an exception. ),i-i.i/i3i4LocationrNzcannot follow redirect to z with a preexisting socketz)cannot follow redirect to non-secure URI rFz'cannot follow cross-origin redirect to z with a Unix socketrrz with an explicit host or portc3PK|]!\}}|dv||fV"dS)) authorizationcookiezproxy-authorizationN)lower).0rrs rI z+connect.process_redirect..s\&C99;;QRRe RRRRrJ)rarr` status_coderSrurllibparseurljoinrur(rrrrrrrrKr raw_items)rGr old_ws_urinew_uri new_ws_uris rIprocess_redirectzconnect.process_redirects  sM * *  (cl222J[ ,&&tx1Ej1QRRw''   ( , ,V 4 4 @PWPPP    XZ%6 X !VW!V!VWW W  !2 2 2*/11*/11,00?? !*g***-11&99E044V<<H!5g555 &2*1*1$2I*J*J*T*T*V*V++'rJc2K tj|j4d{VttD]}|d{V} ||j|jd{V| |ccdddd{VS#tj $r|j t$rq}|j ||}t|tr||ur||||_t#||_Yd}~ d}~wwxYwt'dtd#1d{VswxYwYdS#t($r}t)d|d}~wwxYw)Nz more than z redirectsz"timed out during opening handshake)rXtimeoutrprange MAX_REDIRECTSrr]rKrMstart_keepaliveCancelledErrorrabortrrrarur(rr TimeoutError)rGrrr exc_or_uris rIr+zconnect.connects* Nt'899% P% P% P% P% P% P% P% P}--$P$PA'+'?'?'A'A!A!A!A!A!A!AJ *(22 3 2<#22444)))G% P% P% P% P% P% P% P% P% P% P% P% P% P% P#1",22444$%%%#,22444%)%:%:3%?%? %j)<< %)S00 %&0c 9(2DH*3J*?*?DK$HHHH)%4((N](N(N(NOOOK% P% P% P% P% P% P% P% P% P% P% P% P% P% P% P% PN N N NCDD# M NseE72E$&B&<E$E7&2E A&E>E$E  E$$ E..E71E.2E77 FFF&Generator[Any, None, ClientConnection]cN|Sr)r+ __await__rs rIrzconnect.__await__7s||~~'')))rJcKt|drtd|d{V|_|jd{VS)Nrzconnect() isn't reentrant)hasattr RuntimeErrorr __aenter__rs rIrzconnect.__aenter__=s` 4 & & <:;; ; $******_//111111111rJexc_typetype[BaseException] | None exc_valueBaseException | None tracebackTracebackType | Nonec`K |j|||d{V |`S#|`wxYwr)r __aexit__)rGrrrs rIrzconnect.__aexit__CsO  228Y RRRRRRRR R    s!)-AsyncIterator[ClientConnection]c&Kd} |4d{V}|WVdddd{Vn#1d{VswxYwYd}n#t$r} ||}n#t$r }|}Yd}~nd}~wwxYw||ur|||||}t|}|jd|t j|dtj |d{VYd}~nd}~wwxYw )NTz0connect failed; reconnecting in %.1f seconds: %sr) rrrqnextrsinforformat_exception_onlystriprXsleep)rGdelaysrrnew_exc raised_excdelays rI __aiter__zconnect.__aiter__Ps*.# " %%%%%%%:$$$$$%%%%%%%%%%%%%%%%%%%%%%%%%%%B? + + + )"44S99GG )))(GGGGGG) c>>&!s*>!2244FV    F3C88;AACC mE**************7 + # sR;'; 1;1; DAD  A2&A-(D -A22BD  D)*rurvrkrwrlrxrmryrnrNrKrLrMrNrorzrr{rpr<r6r<r7r<r8r<rqr|rrr=r9r=r:r>rsr}rtr~rrr?r@r)rrr?r)r?r)rrrrrrr?r@)r?r)rdrerfrgrrrrCrrr+rrrrrJrIr+r+sBBR!%>B59"+15(2,0EV%'&(%'&(;B?D@B49$(;?7QQQQQQfccccJFFFFP+N+N+N+N^**** 2222     %%%%%%rJr+pathPathLike | NonerurNrrr?c Z||dd}nd}td|d|d|S)a Connect to a WebSocket server listening on a Unix socket. This function accepts the same keyword arguments as :func:`connect`. It's 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. ``uri`` defaults to ``ws://localhost/`` or, when a ``ssl`` argument is provided, to ``wss://localhost/``. Nrzws://localhost/zwss://localhost/T)rurrr)rr+)rrurs rIr,r,xsD* { ::e   $#CC$C  ;sD ; ;F ; ;;rJ) ProxyType)r)socks5hsocks5socks4asocks4TFrorrr' socket.socketc .Ktt|j|j|j|j|jt|j} |j|j|jfi|d{VS#t$rt$r}td|d}~wwxYw)z0Connect via a SOCKS proxy and return the socket.Nz failed to connect to SOCKS proxy) SocksProxySOCKS_PROXY_TYPESrrrusernamepasswordSOCKS_PROXY_RDNSr+OSErrorrr)rorr socks_proxyrs rIrrs ! el + J J N N U\ *    J,,V[&+PPPPPPPPPP P     J J J?@@c I Js A++B?BBc$Ktd)Nz6connecting through a SOCKS proxy requires python-socks) ImportError)rorrs rIrrs RSSSrJcBeZdZ dddZdd ZddZddZddZddZdS)HTTPProxyConnectionNrr'rorrMrNc$||_||_||_t|_t j|jj|jj|jj d|_ tj }| |_dS)NT)ro)rrorMr"readerrr read_line read_exact read_to_eofparserrXrrEr`)rGrrorMrDs rIrCzHTTPProxyConnection.__init__s   !2"nn n K ! K " K #     '))262D2D2F2F rJr?r@c|jrdS t|jdS#t$ro}|j}d|jcxkrdkrnn|j|n-|jt|Yd}~dSYd}~dSd}~wt$r;}td}||_ |j|Yd}~dSd}~wwxYw)Nrz0did not receive a valid HTTP response from proxy) r`donerr  StopIterationrrrb set_exceptionrrr __cause__)rGrr` proxy_excs rI run_parserzHTTPProxyConnection.run_parsers@ =      F 3       J J JyHh*0000S00000 ((2222 ++,>x,H,HIIIIIIIII322222 3 3 3+BI#&I  M ' ' 2 2 2 2 2 2 2 2 2  3s!3 C/AB'' C/40C**C/rasyncio.BaseTransportcttj|}||_|jt |j|j|jdSr) r rX Transportrwriter!rorrM)rGrs rIrz#HTTPProxyConnection.connection_madesU*I66 "  #DJ T=S T T     rJdatabytescb|j||dSr)r feed_datar)rGrs rI data_receivedz!HTTPProxyConnection.data_receiveds. d### rJc`|j|dSrrfeed_eofrrs rI eof_receivedz HTTPProxyConnection.eof_received,  rJrException | Nonec`|j|dSrr)rGrs rIconnection_lostz#HTTPProxyConnection.connection_lostr rJr)rr'rorrMrN)r?r@)rrr?r@)rrr?r@)rr!r?r@) rdrerfrCrrrrr#rrJrIrrs )- GGGGG*3333$    rJr)rMrMasyncio.TransportcKtjjfdjjfi|d{V\}} |jd{Vn/#tjtf$r|wxYw|S)Nc&tSr)r)rorMrsrIz$connect_http_proxy..s#FE3DEErJ) rXrrtrrr`rrr)rorrMrrr;s``` rIrrs!M 8 : : LEEEEEE  !!  !!Ix  "I .  s A,A:)NN)rrrurNrrr?r+)rorrr'rrr?r) rorrr'rMrNrrr?r$)T __future__rrXrossocketrrr urllib.parsercollections.abcrrrtypesrtypingrr r r clientr rrdatastructuresrr exceptionsrrrrrextensions.baserextensions.permessage_deflaterrSrhttp11rrr;rrrorrr r!streamsr"r#r$r%r&rur'r(rr*__all__intenvironrrr-r+r, python_socksrpython_socks.async_.asynciorSOCKS5SOCKS4rrrrProtocolrrrrJrIr>s"""""" >>>>>>>>>>////////////??????????11111111544444LLLLLL++++++))))))))((((((((JJJJJJJJJJJJ"""""">>>>>>>>>>>>))))))))"""""" : 9 9BJNN#=tDDEE W)W)W)W)W)zW)W)W)vrrrrrrrrl!<<<<<:2J&&&&&&??????#"#"  JJJJJ1TTTTTTTTTTb99999'*999@%) s8 D++ D76D7