5iF]$dZddlZddlZddlmZmZmZmZm Z m Z ddl m Z m Z mZmZddlZddlmZddlmZddlmZddlmZmZmZmZmZddlZGd d eZGd d eZGd deZ GddeZ!Gdde!Z"Gdde!Z#y)z HTTP AsyncIO support This module provides asyncio wrappers around the awscrt.http module. All network operations in `awscrt.aio.http` are asynchronous and use Python's asyncio framework. N)HttpClientConnectionBase HttpRequestHttpClientStreamBaseHttpProxyOptions Http2Setting HttpVersion)ClientBootstrap SocketOptionsTlsConnectionOptions InputStream)deque)BytesIO)Future)ListTupleOptionalCallable AsyncIteratorceZdZdZe ddededeedee dee dee d e d eed dfd Z dd Z ddddeedeej$d dfdZy)AIOHttpClientConnectionUnifiedz An async unified HTTP client connection for either a HTTP/1 or HTTP/2 connection. Use `AIOHttpClientConnectionUnified.new()` to establish a new connection. N host_nameport bootstrapsocket_optionstls_connection_options proxy_optionsmanual_window_managementinitial_window_sizereturnc |K|j||||||d|| } tj| d{S7w)a! Asynchronously establish a new AIOHttpClientConnectionUnified. Args: host_name (str): Connect to host. port (int): Connect to port. bootstrap (Optional [ClientBootstrap]): Client bootstrap to use when initiating socket connection. If None is provided, the default singleton is used. socket_options (Optional[SocketOptions]): Optional socket options. If None is provided, then default options are used. tls_connection_options (Optional[TlsConnectionOptions]): Optional TLS connection options. If None is provided, then the connection will be attempted over plain-text. proxy_options (Optional[HttpProxyOptions]): Optional proxy options. If None is provided then a proxy is not used. manual_window_management (bool): Set to True to manually manage the flow-control window of each stream. If False, the connection maintains flow-control windows such that no back-pressure is applied and data arrives as fast as possible. If True, the flow-control window of each stream shrinks as body data is received (headers, padding, and other metadata do not affect the window). `initial_window_size` determines the starting size of each stream's window. When a stream's window reaches 0, no further data is received until `update_window()` is called. For HTTP/2, this only controls stream windows; connection window is controlled by `conn_manual_window_management`. Default is False. initial_window_size (Optional[int]): The starting size of each stream's flow-control window. Required if `manual_window_management` is True, ignored otherwise. For HTTP/2, this becomes the `INITIAL_WINDOW_SIZE` setting and can be overridden by `initial_settings`. Must be <= 2^31-1 or connection fails. If set to 0 with `manual_window_management` True, streams start with zero window. Required if manual_window_management is True, ignored otherwise. Returns: AIOHttpClientConnectionUnified: A new unified HTTP client connection. T)asyncio_connectionrrN) _generic_newasyncio wrap_future) clsrrrrrrrrfutures q/home/marpiech/ifpan-abm-pgxpred/analysis/marpiech-gwas-test/venv/lib/python3.12/site-packages/awscrt/aio/http.pynewz"AIOHttpClientConnectionUnified.new#sRf!!     " #%= 3" 5((0000s 3<:<cKtj|jtj|j d{y7w)zClose the connection asynchronously. Shutdown is asynchronous. This call has no effect if the connection is already closing. Returns: None: When shutdown is complete. N)_awscrthttp_connection_close_bindingr#r$shutdown_futureselfs r'closez$AIOHttpClientConnectionUnified.closebs4 %%dmm4!!$"6"6777sAA A A requestrrequest_body_generatorloopAIOHttpClientStreamUnifiedct||||S)aCreate `AIOHttpClientStreamUnified` to carry out the request/response exchange. Args: request (HttpRequest): Definition for outgoing request. request_body_generator (AsyncIterator[bytes], optional): Async iterator providing chunks of the request body. If provided, the body will be sent incrementally as chunks become available. loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations. If None, the current event loop is used. Returns: AIOHttpClientStreamUnified: Stream for the HTTP request/response exchange. )r4r/r1r2r3s r'r1z&AIOHttpClientConnectionUnified.requestns *$9OQUVV)NNNNFNrNNN)__name__ __module__ __qualname____doc__ classmethodstrintrr r r rboolr(r0rbytesr#AbstractEventLoopr1r7r'rrs :><@KO>B387;<1 <1<1&o6<1#+="9 <1 +33G*H <1 "**:!; <1-1<1(0}<1Aa<1<1| 8@D<@W&W(5e(<Ww889WFbWr7rceZdZdZe ddededeedee dee dee d e d eed eed dfd Z ddddeedeej"d dfdZy)AIOHttpClientConnectionz{ An async HTTP/1.1 only client connection. Use `AIOHttpClientConnection.new()` to establish a new connection. Nrrrrrrrrread_buffer_capacityrc K|j||||||tjd|||  } tj| d{S7w)a Asynchronously establish a new AIOHttpClientConnection. Args: host_name (str): Connect to host. port (int): Connect to port. bootstrap (Optional [ClientBootstrap]): Client bootstrap to use when initiating socket connection. If None is provided, the default singleton is used. socket_options (Optional[SocketOptions]): Optional socket options. If None is provided, then default options are used. tls_connection_options (Optional[TlsConnectionOptions]): Optional TLS connection options. If None is provided, then the connection will be attempted over plain-text. proxy_options (Optional[HttpProxyOptions]): Optional proxy options. If None is provided then a proxy is not used. manual_window_management (bool): If True, enables manual flow control window management. Default is False. initial_window_size (Optional[int]): Initial window size for flow control. Required if manual_window_management is True, ignored otherwise. read_buffer_capacity (Optional[int]): Capacity in bytes of the HTTP/1.1 connection's read buffer. The buffer grows when the flow-control window of the incoming stream reaches zero. Ignored if `manual_window_management` is False. A capacity that is too small may hinder throughput. A capacity that is too large may waste memory without improving throughput. If None or zero, a default value is used. Returns: AIOHttpClientConnection: A new HTTP client connection. T)expected_versionr!rrrGN)r"rHttp1_1r#r$) r%rrrrrrrrrGr&s r'r(zAIOHttpClientConnection.news^^!!     " (00#%= 3!5" 7((0000sAA A A r1rr2r3AIOHttpClientStreamct|||S)a|Create `AIOHttpClientStream` to carry out the request/response exchange. Args: request (HttpRequest): Definition for outgoing request. request_body_generator (AsyncIterator[bytes], optional): Async iterator providing chunks of the request body. Not supported for HTTP/1.1 connections yet, use the request's body_stream instead. loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations. If None, the current event loop is used. Returns: AIOHttpClientStream: Stream for the HTTP request/response exchange. )rKr6s r'r1zAIOHttpClientConnection.requests #4$77r7)NNNNFNNr9)r:r;r<r=r>r?r@rr r r rrAr(rrBr#rCr1rDr7r'rFrFs :><@KO>B387;8<:1 :1:1&o6:1#+="9 :1 +33G*H :1 "**:!; :1-1:1(0}:1)1 :1B[:1:1|@D<@8&8(5e(<8w8898F[8r7rFceZdZdZe ddededeedee dee dee d ee e d eee e gdfd ed eed edeedeeddfdZ ddddeedeej(ddfdZdeddfdZy)AIOHttp2ClientConnectionzz An async HTTP/2 only client connection. Use `AIOHttp2ClientConnection.new()` to establish a new connection. Nrrrrrrinitial_settingson_remote_settings_changedrrconn_manual_window_managementconn_window_size_thresholdstream_window_size_thresholdrcK|j||||||tj||d| | | | | }tj|d{S7w)a Asynchronously establish an HTTP/2 client connection. Notes: to set up the connection, the server must support HTTP/2 and TlsConnectionOptions This class extends AIOHttpClientConnection with HTTP/2 specific functionality. HTTP/2 specific args: initial_settings (List[Http2Setting]): The initial settings to change for the connection. on_remote_settings_changed: Optional callback invoked once the remote peer changes its settings. And the settings are acknowledged by the local connection. The function should take the following arguments and return nothing: * `settings` (List[Http2Setting]): List of settings that were changed. manual_window_management (bool): If True, enables manual flow control window management. Default is False. initial_window_size (Optional[int]): Initial window size for flow control. Required if manual_window_management is True, ignored otherwise. conn_manual_window_management (bool): If True, enables manual connection-level flow control for the entire HTTP/2 connection. When enabled, the connection's flow-control window shrinks as body data is received across all streams. The initial connection window is 65,535 bytes. When the window reaches 0, all streams stop receiving data until `update_window()` is called to increment the connection's window. Note: Padding in DATA frames counts against the window, but window updates for padding are sent automatically even in manual mode. Default is False. conn_window_size_threshold (Optional[int]): Threshold for sending connection-level WINDOW_UPDATE frames. Ignored if `conn_manual_window_management` is False. When the connection's window is above this threshold, WINDOW_UPDATE frames are batched. When it drops below, the update is sent. Default is 32,767 (half of the initial 65,535 window). stream_window_size_threshold (Optional[int]): Threshold for sending stream-level WINDOW_UPDATE frames. Ignored if `manual_window_management` is False. When a stream's window is above this threshold, WINDOW_UPDATE frames are batched. When it drops below, the update is sent. Default is half of `initial_window_size`. T) rIrOrPr!rrrQrRrSN)r"rHttp2r#r$)r%rrrrrrrOrPrrrQrRrSr&s r'r(zAIOHttp2ClientConnection.newskl!!     " (..-'A#%= 3*G'A)E"G ((0000sAA A Ar1rr2r3AIOHttp2ClientStreamct||||S)aCreate `AIOHttp2ClientStream` to carry out the request/response exchange. Args: request (HttpRequest): Definition for outgoing request. request_body_generator (AsyncIterator[bytes], optional): Async iterator providing chunks of the request body. If provided, the body will be sent incrementally as chunks become available from the iterator. loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations. If None, the current event loop is used. Returns: AIOHttp2ClientStream: Stream for the HTTP/2 request/response exchange. )rVr6s r'r1z AIOHttp2ClientConnection.request's $D'3I4PPr7increment_sizecDtj|j|y)z Update the connection's flow control window. Args: increment_size (int): Number of bytes to increment the window by. N)r*http2_connection_update_windowr,)r/rXs r' update_windowz&AIOHttp2ClientConnection.update_window9s ..t}}nMr7) NNNNNNFNFNNr9)r:r;r<r=r>r?r@rr r r rrrrrAr(rrBr#rCr1r[rDr7r'rNrNs} :><@KO>BCG_c387;8=>B@DE1 E1E1&o6E1#+="9 E1 +33G*H E1 "**:!; E1%-T,-?$@E1/7xlAS@TVZ@Z7[.\E1-1E1(0}E126E1/7smE119 E1JdE1E1R@D<@Q&Q(5e(<Qw889QF\Q$NCNDNr7rNc eZdZdZ ddededeedee jddf fd Z d e d e eeefddfd Zd eddfd ZddZde ddfdZddZdeefdZde fdZde eeeffdZdefdZde fdZxZS)r4) _response_status_future_response_headers_future_chunk_futures_received_chunks_completion_future_stream_completed _status_code_loop _deque_lockN connectionr1r2r3rc|duxr|jtju}t|||||t j }n%t|t js td||_ tj|_ t|_t|_d|_t%|_t%|_t%|_t%|_d|_||_|j09|jj3|j5|j0|_t9j:|y)N)http2_manual_writez5loop must be an instance of asyncio.AbstractEventLoopF)versionrrUsuper _init_commonr#get_event_loop isinstancerC TypeErrorrd threadingLockrer r_r`rbrra_remote_completion_futurer]r^rc_request_body_generator create_task_set_request_body_generator_writerr*http_client_stream_activate)r/rfr1r2r3rh __class__s r'__init__z#AIOHttpClientStreamUnified.__init__Os44?kJDVDVZeZkZkDk ZEWX <))+DD'";";<ST T %>>+#g %!&#)()/&'-x$(.% '=$  ' ' 3::11$2R2RSWSoSo2pqDL ++D1r7 status_codename_value_pairsc~||_|jj||jj|yN)rcr] set_resultr^)r/ryrzs r' _on_responsez'AIOHttpClientStreamUnified._on_responseus3' $$// < %%001ABr7chunkc|j5|jr|jj}n%|jj | dddy dddj |y#1swYxYw)z*Process body chunk - called from C thread.N)rer_popleftr`appendr})r/rr&s r'_on_bodyz#AIOHttpClientStreamUnified._on_body{sq    "",,446%%,,U3     %   s AA55A>c|j5t|j}|jjdddD]}|j dy#1swY"xYw)zHelper to resolve all pending chunk futures with empty bytes. This indicates end of stream to any waiting get_next_response_chunk() calls. Must be called when either the stream completes or remote peer sends END_STREAM. Nr7)relistr_clearr})r/pending_futuresr&s r'_resolve_pending_chunk_futuresz9AIOHttpClientStreamUnified._resolve_pending_chunk_futuressc   ("4#6#67O    % % ' ( & #F   c " #  ( (s 0AA' error_codec|dk(r&|jj|jn8|jjtj j ||jy)z(Set the completion status of the stream.rN)rar}rc set_exceptionawscrt exceptions from_coder)r/rs r' _on_completez'AIOHttpClientStreamUnified._on_completesT ?  # # . .t/@/@ A  # # 1 1&2C2C2M2Mj2Y Z ++-r7cZ|jjd|jy)z?Called when the remote peer has finished sending (HTTP/2 only).N)rqr}rr.s r'_on_h2_remote_end_streamz3AIOHttpClientStreamUnified._on_h2_remote_end_streams" &&11$7 ++-r7 body_iteratorc Kywr|rD)r/rs r'rtz6AIOHttpClientStreamUnified._set_request_body_generators  sctKtj|j|jd{S7w)zrGet the response status code asynchronously. Returns: int: The response status code. r3N)r#r$r]rdr.s r'get_response_status_codez3AIOHttpClientStreamUnified.get_response_status_codes+ (()E)EDJJWWWW /868ctKtj|j|jd{S7w)zGet the response headers asynchronously. Returns: List[Tuple[str, str]]: The response headers as a list of (name, value) tuples. rN)r#r$r^rdr.s r'get_response_headersz/AIOHttpClientStreamUnified.get_response_headerss+ (()F)FTZZXXXXrcK|j5|jr#|jjcdddS|jj s|j j r dddyt }|jj| dddtj|jd{S#1swY2xYw7w)zGet the next chunk from the response body. Returns: bytes: The next chunk of data from the response body. Returns empty bytes when the stream is completed and no more chunks are left. Nr7r) rer`rradonerqrr_rr#r$rd)r/r&s r'get_next_response_chunkz2AIOHttpClientStreamUnified.get_next_response_chunks   3$$,,446 3 3((--/43Q3Q3V3V3X  3 3  ##**62 3((djjAAA 3 3Bs> C"&C C"5C4 C"=%C#,C"C C"CC"ctKtj|j|jd{S7w)zuWait asynchronously for the stream to complete. Returns: int: The response status code. rN)r#r$rardr.s r'wait_for_completionz.AIOHttpClientStreamUnified.wait_for_completions+ (()@)@tzzRRRRrr9r8)r:r;r< __slots__rFrrrBrr#rCrxr@rrr?r~rrrrrtrrrr __classcell__rws@r'r4r4Cs  IAE=A $24$2%$2*7u)=$2  9 9: $2GK $2LCCtE#s(O?TCY]C !e ! ! #.s.t..  }U?S XXYDsCx,AYBuB&S3Sr7r4c ReZdZdZ ddededeejddffd Z xZ S) rKaAsync HTTP stream that sends a request and receives a response. Create an AIOHttpClientStream with `AIOHttpClientConnection.request()`. Attributes: connection (AIOHttpClientConnection): This stream's connection. completion_future (asyncio.Future): Future that will contain the response status code (int) when the request/response exchange completes. If the exchange fails to complete, the Future will contain an exception indicating why it failed. Notes: All async method on a stream (await stream.next(), etc.) must be performed in the thread that owns the event loop used to create the stream Nrfr1r3rc*t||||y)ahInitialize an HTTP client stream. Args: connection (AIOHttpClientConnection): The connection to send the request on. request (HttpRequest): The HTTP request to send. loop (Optional[asyncio.AbstractEventLoop]): Event loop to use for async operations. If None, the current event loop is used. rNrjrx)r/rfr1r3rws r'rxzAIOHttpClientStream.__init__s W48r7r|) r:r;r<r=rFrrr#rCrxrrs@r'rKrKsB$>B 9#: 9[ 9 9 9: 9FJ 9 9r7rKc veZdZdZ d dededeedee jddf fd Z d Z d eefd Z xZS) rVzHTTP/2 stream that sends a request and receives a response. Create an AIOHttp2ClientStream with `AIOHttp2ClientConnection.request()`. Nrfr1r2r3rc,t|||||y)N)r2r3r)r/rfr1r2r3rws r'rxzAIOHttp2ClientStream.__init__s WE[bfgr7cKttj|d}dtddffd }t j ||||t j|jd{y7w)NT) allow_nonerrcjry|r/jtjj |yj dyr|) cancelledrrrrr})rr&s r'on_write_completez;AIOHttp2ClientStream._write_data..on_write_completesB!$$V%6%6%@%@%LM!!$'r7r) rr wrapr@r*http2_client_stream_write_datar#r$rd)r/body end_stream body_streamrr&s @r' _write_dataz AIOHttp2ClientStream._write_datasd!&&t=  (# ($ ( ..t[*N_`!!&tzz:::sA,A7/A50A7rcK |23d{}|jt|dd{-7(76 |jddd{7y#|jddd{7wxYww)NFT)rr)r/rrs r'rtz0AIOHttp2ClientStream._set_request_body_generatorsq /, > >e&&wu~u=== >= -""4. . .$""4. . .s[A5A737A5A7AAA5AA5A2+A.,A22A5r9)r:r;r<r=rFrrrBrr#rCrxrrtrrs@r'rVrVssAE=A h4h%h*7u)=h  9 9: hGK h; /}U?S/r7rV)$r=r*awscrt.exceptionsr awscrt.httprrrrrr awscrt.ior r r r r# collectionsr iorconcurrent.futuresrtypingrrrrrrorrFrNr4rKrVrDr7r'rs%AAbW%=bWJT8<T8nhN=hNVMS!5MS`949>"/5"/r7