5i'dZddlZddlmZddlmZddlZddlmZm Z m Z m Z ddl m Z ddlmZmZmZmZmZmZmZmZGdd e ZGd d e ZGd d ZGddeZGddeZGddeZGddeZGddeZGddeZGddeZ GddeZ!GddeZ"Gd d!e"Z#Gd"d#eZ$Gd$d%e Z%Gd&d'e Z&Gd(d)Z'Gd*d+Z(y),zA HTTP All network operations in `awscrt.http` are asynchronous. N)Future)NativeResource)ClientBootstrap InputStreamTlsConnectionOptions SocketOptions)IntEnum)ListTupleDictOptionalUnionIteratorCallableAnyc eZdZdZdZdZdZdZy) HttpVersionz!HTTP protocol version enumerationrN)__name__ __module__ __qualname____doc__UnknownHttp1_0Http1_1Http2m/home/marpiech/ifpan-abm-pgxpred/analysis/marpiech-gwas-test/venv/lib/python3.12/site-packages/awscrt/http.pyrrs+GGG Er rc(eZdZdZdZdZdZdZdZdZ y) Http2SettingIDz+HTTP/2 Predefined settings(RFC-9113 6.5.2).rrrN) rrrrHEADER_TABLE_SIZE ENABLE_PUSHMAX_CONCURRENT_STREAMSINITIAL_WINDOW_SIZEMAX_FRAME_SIZEMAX_HEADER_LIST_SIZErr r!r#r#s'5KNr r#c eZdZUdZej dej dejdejdejdejdiZ e ee eeffed<deded d fd Zdeded d fd Zd efd Zy ) Http2SettingaHTTP/2 Setting. Settings are very complicated in HTTP/2. Each end has its own settings, and the local settings cannot be applied until the remote end acknowledges it. Each end can change its settings at any time, while the order of the settings changed may also result in different behavior. Each setting has its boundary and initial values defined in RFC-9113 6.5.2: Initial values are listed below, while the range can be found in VALID_RANGES: HEADER_TABLE_SIZE: 4096 ENABLE_PUSH: 1 MAX_CONCURRENT_STREAMS: 2^32-1 INITIAL_WINDOW_SIZE: 2^16-1 MAX_FRAME_SIZE: 2^14 MAX_HEADER_LIST_SIZE: 2^32-1 Args: id (Http2SettingID): Setting ID. value (int): Setting value. )rl)rr)ri)i@i VALID_RANGESidvaluereturnNct|tsJt|tsJ||_|j ||||_yN) isinstancer#intr0_validate_setting_valuer1)selfr0r1s r!__init__zHttp2Setting.__init__CsB"n---%%%% $$R/ r c |j|\}}||cxkr|ks$n|j}t|d|d|d|y)zTValidate that setting value is within its allowed range according to RFC-9113 6.5.2.z must be between z and z, got N)r/name ValueError)r8r0r1 min_value max_value setting_names r!r7z$Http2Setting._validate_setting_valueLsX#004 9E.Y.77L ~->ykykY_`e_fgh h/r c~|jjd|jjd|jdzS)N(=)) __class__rr0r;r1r8s r!__str__zHttp2Setting.__str__Ss2~~&&1TWW\\N!DJJ#$i.iiiJJr r.c\eZdZdZdZdfd Zed dZedefdZ de fdZ xZ S) HttpConnectionBasez!Base for HTTP connection classes.)_shutdown_future_versionr2c@t|t|_yr4)superr9rrK)r8rDs r!r9zHttpConnectionBase.__init__\s  &r c|jS)a& concurrent.futures.Future: Completes when this connection has finished shutting down. Future will contain a result of None, or an exception indicating why shutdown occurred. Note that the connection may have been garbage-collected before this future completes. )rKrEs r!shutdown_futurez"HttpConnectionBase.shutdown_future`s$$$r c|jS)z-HttpVersion: Protocol used by this connectionrLrEs r!versionzHttpConnectionBase.versioni}}r c@tj|jS)z Returns: bool: True if this connection is open and usable, False otherwise. Check :attr:`shutdown_future` to know when the connection is completely finished shutting down. )_awscrthttp_connection_is_open_bindingrEs r!is_openzHttpConnectionBase.is_openns..t}}==r r2Nr2concurrent.futures.Future) rrrr __slots__r9propertyrPrrSboolrY __classcell__rDs@r!rJrJWsK+0I)%%>>r rJc"eZdZdZe ddededeedee dee ded d ee d ee e d eee e gdfd edeedeededeedeeddf dZedefdZedefdZy)HttpClientConnectionBase _host_name_portN host_nameport bootstrapsocket_optionstls_connection_options proxy_optionsHttpProxyOptionsexpected_versioninitial_settingson_remote_settings_changedmanual_window_managementinitial_window_sizeread_buffer_capacityconn_manual_window_managementconn_window_size_thresholdstream_window_size_thresholdr2r\ct|ts|Jt|tsJt|tsJt|ts|Jt|t s|Jt|t s|J| r| Jt} |s t }|stj}t|||||||| }tj|||||||||| | | | |||S#t$r}|j|Yd}~|Sd}~wwxYw)zP Initialize the generic part of the HttpClientConnection class. N)rirkconnect_futurernrpasyncio_connection)r5rrHr6rrrmrget_or_create_static_default_HttpClientConnectionCorerVhttp_client_connection_new Exception set_exception)rgrhrirjrkrlrnrorpryrqrrrsrtrurvfutureconnection_corees r! _generic_newz%HttpClientConnectionBase._generic_new{s@*)_59JJJ)S)))$$$$02FGKaKiii.-8NSSS+/B/NNN# $!!.+HHJ 7#'=%!1+E#57O  . .& *(#$-*, .(  $   # #  $sAC D)DDc|jS)zRemote hostname)rerEs r!rgz"HttpClientConnectionBase.host_namesr c|jS)z Remote port)rfrEs r!rhzHttpClientConnectionBase.portszzr )NNNNNNNFFNNFNN)rrrr] staticmethodrHr6r rrrrr r.rr_rr^rgrhrr r!rcrcxsy'I486:EI:>6:=AY]$-21526278<:>!CCC 0C%]3 C %--A$B C $$67 C'{3C'tL'9:C)14 ;M:NPT:T1U(VC'+C"*#C#+3-C,0C)1 C +33-!C D_!CCJ3cr rcceZdZdZdZe ddededee dee dee d ed d e d eed eeddfdZ ddddeeddeedddfdZddZy)HttpClientConnectionzo An HTTP client connection. Use :meth:`HttpClientConnection.new()` to establish a new connection. rdNrgrhrirjrkrlrmrqrrrsr2r\c 6|j|||||||||  S)a Asynchronously establish a new HttpClientConnection. 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. 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. 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. 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: concurrent.futures.Future: A Future which completes when connection succeeds or fails. If successful, the Future will contain a new :class:`HttpClientConnection`. Otherwise, it will contain an exception. )rqrrrs)r) clsrgrhrirjrkrlrqrrrss r!newzHttpClientConnection.news8t     " %= 3!5 7 7r request HttpRequest on_response.Non_bodyHttpClientStreamct||||S)anCreate :class:`HttpClientStream` to carry out the request/response exchange. NOTE: The HTTP stream sends no data until :meth:`HttpClientStream.activate()` is called. Call activate() when you're ready for callbacks and events to fire. Args: request (HttpRequest): Definition for outgoing request. on_response: Optional callback invoked once main response headers are received. The function should take the following arguments and return nothing: * `http_stream` (:class:`HttpClientStream`): HTTP stream carrying out this request/response exchange. * `status_code` (int): Response status code. * `headers` (List[Tuple[str, str]]): Response headers as a list of (name,value) pairs. * `**kwargs` (dict): Forward compatibility kwargs. An exception raise by this function will cause the HTTP stream to end in error. This callback is always invoked on the connection's event-loop thread. on_body: Optional callback invoked 0+ times as response body data is received. The function should take the following arguments and return nothing: * `http_stream` (:class:`HttpClientStream`): HTTP stream carrying out this request/response exchange. * `chunk` (buffer): Response body data (not necessarily a whole "chunk" of chunked encoding). * `**kwargs` (dict): Forward-compatibility kwargs. An exception raise by this function will cause the HTTP stream to end in error. This callback is always invoked on the connection's event-loop thread. Returns: HttpClientStream: )r)r8rrrs r!rzHttpClientConnection.requestsZ g{GDDr cXtj|j|jSa#Close the connection. Shutdown is asynchronous. This call has no effect if the connection is already closing. Returns: concurrent.futures.Future: This connection's :attr:`shutdown_future`, which completes when shutdown has finished. rVhttp_connection_closerXrPrEs r!closezHttpClientConnection.closeH" %%dmm4###r )NNNNFNNNNr[)rrrrr] classmethodrHr6r rrrr_rrrrrr r!rrs (I486:EI:>-21526B7B7B7 0B7%]3 B7 %--A$B B7 $$67 B7'+B7"*#B7#+3-B7B9=-E&-E%hy&9:-E"(9"56-ECU-E^ $r rceZdZe ddededeedeedee dedd ee e d ee e e gdfd e d eed e deedeeddfdZ ddddee ddee dde ddf dZd dZdeddfdZy)!Http2ClientConnectionNrgrhrirjrkrlrmrorprqrrrtrurvr2r\c\|j||||||tj||| | | | | S)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 HttpClientConnection 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`. )rqrrrtrurv)rrr)rrgrhrirjrkrlrorprqrrrtrurvs r!rzHttp2ClientConnection.newXsOn     "      &%= 3*G'A)E G Gr rrrrr manual_writeHttp2ClientStreamc t|||||S)a(Create `Http2ClientStream` to carry out the request/response exchange. NOTE: The HTTP stream sends no data until `Http2ClientStream.activate()` is called. Call activate() when you're ready for callbacks and events to fire. Args: request (HttpRequest): Definition for outgoing request. on_response: Optional callback invoked once main response headers are received. The function should take the following arguments and return nothing: * `http_stream` (`Http2ClientStream`): HTTP/2 stream carrying out this request/response exchange. * `status_code` (int): Response status code. * `headers` (List[Tuple[str, str]]): Response headers as a list of (name,value) pairs. * `**kwargs` (dict): Forward compatibility kwargs. on_body: Optional callback invoked 0+ times as response body data is received. The function should take the following arguments and return nothing: * `http_stream` (`Http2ClientStream`): HTTP/2 stream carrying out this request/response exchange. * `chunk` (buffer): Response body data (not necessarily a whole "chunk" of chunked encoding). * `**kwargs` (dict): Forward-compatibility kwargs. manual_write (bool): If True, enables manual data writing on the stream. This allows calling `write_data()` to stream the request body in chunks. Note: In the asyncio version, this is replaced by the async_body parameter. Returns: Http2ClientStream: Stream for the HTTP/2 request/response exchange. )r)r8rrrrs r!rzHttp2ClientConnection.requestsX!w WlSSr cXtj|j|jSrrrEs r!rzHttp2ClientConnection.closerr increment_sizecDtj|j|y)z Update the connection's flow control window. Args: increment_size (int): Number of bytes to increment the window by. N)rVhttp2_connection_update_windowrXr8rs r! update_windowz#Http2ClientConnection.update_windows ..t}}nMr ) NNNNNNFNFNNNNFr[)rrrrrHr6r rrrr r.rr_rrrrrr r!rrVs486:EI:>=ACG-215278<:>DGDGDG 0DG%]3 DG %--A$B DG $$67 DG'tL'9:DG)14 ;M:N:>;?2@)ADG'+DG"*#DG,0DG)1 DG+33-DGD_DGDGP>B9=%* ,T&,T%hy&9:,T"(9"56,T# ,T0C ,T\ $NCNDNr rcveZdZdZdZd deedddffd Zede fdZ ed d Z d e ddfd Z xZS)HttpStreamBasezBase for HTTP stream classes. Attributes: connection: The HTTP connection this stream belongs to. completion_future: Future that completes when the operation finishes. ) _connection_completion_future _on_body_cbNrrr2c\t|||_t|_||_yr4)rNr9rrrr)r8 connectionrrDs r!r9zHttpStreamBase.__init__s( %"((:Ar c|jSr4)rrEs r!rzHttpStreamBase.connectionsr c|jSr4)rrEs r!completion_futurez HttpStreamBase.completion_futures&&&r chunkcD|jr|j||yy)N) http_streamr)r)r8rs r!_on_bodyzHttpStreamBase._on_bodys#      U  ; r r4r[)rrrrr]r rr9r^rJrrbytesrr`ras@r!rrst EIBHXi5H,IBUYB  .  ''???';/// $ (;;; GO33 W->I48"  "** 66tZRde r c|jS)z)HttpVersion: Protocol used by this streamrRrEs r!rSzHttpClientStreamBase.version!rTr c|jS)zNint: The response status code. This is None until a response arrives.)rrEs r!response_status_codez)HttpClientStreamBase.response_status_code&s )))r status_codename_value_pairscT||_|jr|j|||yy)N)rrheaders)rr)r8rrs r! _on_responsez!HttpClientStreamBase._on_response-s.%0"     T{Td e r error_codecd|_|dk(r&|jj|jy|jj t j j|y)Nr)rr set_resultrr~awscrt exceptions from_coder8rs r! _on_completez!HttpClientStreamBase._on_complete3sO ?  # # . .t/I/I J  # # 1 1&2C2C2M2Mj2Y Zr cy)zCalled when remote peer sends END_STREAM (HTTP/2 only). This callback is only invoked for HTTP/2 connections. HTTP/1.x streams will never receive this callback. Base implementation does nothing. NrrEs r!_on_h2_remote_end_streamz-HttpClientStreamBase._on_h2_remote_end_stream<s r rc0tj||y)z Update the stream's flow control window. Args: increment_size (int): Number of bytes to increment the window by. N)rVhttp_stream_update_windowrs r!rz"HttpClientStreamBase.update_windowDs ))$?r rrZ)rrrrr]rcr rr_rr^rrSr6rr r rHrrrrr`ras@r!rrs dI CG>B05 f!9f+f#+8I+>"?f'x ':; f *. f ;? f**hsm** fftE#s(O?TfY]f [s[t[ @C@D@r rc ReZdZdZ d dedddeeddeedd df d Zd d Zy)raHTTP stream that sends a request and receives a response. Create an HttpClientStream with :meth:`HttpClientConnection.request()`. NOTE: The HTTP stream sends no data until :meth:`HttpClientStream.activate()` is called. Call activate() when you're ready for callbacks and events to fire. Attributes: connection (HttpClientConnection): This stream's connection. completion_future (concurrent.futures.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. Nrrrrrrr2c,|j||||yr4)r)r8rrrrs r!r9zHttpClientStream.__init___s *g{GDr c.tj|yzBegin sending the request. The HTTP stream does nothing until this is called. Call activate() when you are ready for its callbacks and events to fire. NrVhttp_client_stream_activaterEs r!activatezHttpClientStream.activatef ++D1r rrZ) rrrrrr rr9rrr r!rrNsd&?C:> E1E'E'x ':;E#8I#67 EDH E2r rc eZdZdZ ddedddeeddeedd ed df d Ze dd Z ddZ de d dfdZ ddZ ddeeefded d fdZy)r_remote_end_stream_futureNrrrrrrrr2cLt|_|j|||||yr4)rrr)r8rrrrrs r!r9zHttp2ClientStream.__init__rs$ *0& *g{G\Rr r\c|jS)a concurrent.futures.Future: Future that completes when the remote peer has finished sending (HTTP/2 only). This occurs when the server sends an END_STREAM flag. The future will contain a result of None on success, or an exception if the stream encounters an error before END_STREAM is received (e.g., RST_STREAM). This is different from `completion_future` which completes when both the client and server have finished (bidirectional stream closure). Note: This future only applies to HTTP/2 connections. It will complete when the server sends END_STREAM, which may occur before the client finishes sending. In case of stream completed without END_STREAM received, this future will complete with exception. rrEs r!remote_end_stream_futurez*Http2ClientStream.remote_end_stream_future{s"---r cp|jjs|jjdyy)zBInternal callback when remote peer sends END_STREAM (HTTP/2 only).N)rdonerrEs r!rz*Http2ClientStream._on_h2_remote_end_streams---224  * * 5 5d ;5r rcTd|_|jjs$|jjt d|dk(r&|j j |jy|j jtjj|y)Nz4Stream completed without receiving remote END_STREAMr) rrrr~ RuntimeErrorrrrrrrrs r!rzHttp2ClientStream._on_completes --224  * * 8 8ST V ?  # # . .t/I/I J  # # 1 1&2C2C2M2Mj2Y Zr c.tj|yrrrEs r!rzHttp2ClientStream.activaterr data_stream end_streamcttj|d}dtddffd }t j ||||S)anWrite a chunk of data to the request body stream. This method is only available when the stream was created with manual_write=True. This allows incremental writing of request data. Note: In the asyncio version, this is replaced by the request_body_generator parameter which accepts an async generator. Args: data_stream (Union[InputStream, Any]): Data to write. If not an InputStream, it will be wrapped in one. Can be None to send an empty chunk. end_stream (bool): True to indicate this is the last chunk and no more data will be sent. False if more chunks will follow. Returns: concurrent.futures.Future: Future that completes when the write operation is done. The future will contain None on success, or an exception on failure. T) allow_nonerr2Ncjry|r/jtjj |yj dyr4) cancelledr~rrrr)rrs r!on_write_completez7Http2ClientStream.write_data..on_write_completesB!$$V%6%6%@%@%LM!!$'r )rrwrapr6rVhttp2_client_stream_write_data)r8rr body_streamrrs @r! write_datazHttp2ClientStream.write_datasM,!&&{tD  (# ($ ( ..t[*N_` r rr[rZ)F)rrrr]rr rr_r9r^rrr6rrrrrrrr r!rros.I ?C:>&+ S1S'S'x ':;S#8I#67 S $ S 15 S..$< [s[t[ 2',# %k3&6 7###0K#r rc eZdZdZdZ ddedddeeeefddffd Z e dd Z e deefd Z e jd eeefddfd Z xZS)HttpMessageBasez8 Base for HttpRequest and HttpResponse classes. )_headers _body_streamNbindingr HttpHeadersrr2ct|tsJt| ||_||_d|_|r||_yyr4)r5rrNr9rXrrr)r8rrrrDs r!r9zHttpMessageBase.__init__sD';///   37 *D  r c|jS)zHttpHeaders: Headers to send.)rrEs r!rzHttpMessageBase.headersrTr c|jSr4)rrEs r!rzHttpMessageBase.body_streams   r streamctj||_tj|j |jyr4)rrrrVhttp_message_set_body_streamrX)r8rs r!rzHttpMessageBase.body_streams/',,V4,,T]]Dr c@tj|jS)z str: HTTP request method (verb).)rVhttp_message_get_request_methodrXrEs r!rzHttpRequest.methods66t}}EEr cDtj|j|yr4)rVhttp_message_set_request_methodrX)r8rs r!rzHttpRequest.method!s// vFr c@tj|jS)zstr: HTTP path-and-query value.)rVhttp_message_get_request_pathrXrEs r!rzHttpRequest.path%s44T]]CCr cBtj|j|Sr4)rVhttp_message_set_request_pathrX)r8rs r!rzHttpRequest.path*s44T]]DIIr )GET/NN)rrrrr]rHr rrrr9rr r^rrrr`ras@r!rrs I % 48BF   #=1 'u[#-='>? LP S3=FFF ]]GSGTGGDcDD [[JJJJr rc:eZdZdZdZddeeeeefddffd Z e de ddffd Z d ed eddfd Z deeeefddfd Zd ed eddfd Zd edeefdZdd edeedeefdZd eddfdZd ed eddfdZddZdeeeeffdZdefdZxZS)ra\ Collection of HTTP headers. A given header name may have multiple values. Header names are always treated in a case-insensitive manner. HttpHeaders can be iterated over as (name,value) pairs. Args: name_value_pairs (Optional[List[Tuple[str, str]]]): Construct from a collection of (name,value) pairs. rNrr2c|t|tj|_|r|j |yyr4)rNr9rVhttp_headers_newrX add_pairs)r8rrDs r!r9zHttpHeaders.__init__>s3 002  NN+ , r rcT|j|}t|| ||_|S)z+Construct from a pre-existing native object)rrNr9rX)rrrrDs r!rzHttpHeaders._from_bindingDs-++c" c7$&"r r;r1ct|tsJt|tsJtj|j||y)zu Add a name-value pair. Args: name (str): Name. value (str): Value. N)r5rHrVhttp_headers_addrXr8r;r1s r!addzHttpHeaders.addL:$$$$%%%%  er>s%+ FJ IVr r>ceZdZdZdZ dZy)HttpProxyAuthenticationTypez&Proxy authentication type enumeration.rrN)rrrrNothingBasicrr r!rCrCs0G Er rCc~eZdZdZdej ddejfdede de e dede ede ed ed dfd Z y) rmaS Proxy options for HTTP clients. Args: host_name (str): Name of the proxy server to connect through. port (int): Port number of the proxy server to connect through. tls_connection_options (Optional[TlsConnectionOptions]): Optional `TlsConnectionOptions` for the Local to Proxy connection. Must be distinct from the `TlsConnectionOptions` provided to the HTTP connection. auth_type (HttpProxyAuthenticationType): Type of proxy authentication to use. Default is :const:`HttpProxyAuthenticationType.Nothing`. auth_username (Optional[str]): Username to use when `auth_type` is :const:`HttpProxyAuthenticationType.Basic`. auth_password (Optional[str]): Username to use when `auth_type` is :const:`HttpProxyAuthenticationType.Basic`. connection_type (Optional[HttpProxyConnectionType): Type of proxy connection to make. Default is :const:`HttpProxyConnectionType.Legacy`. Attributes: host_name (str): Name of the proxy server to connect through. port (int): Port number of the proxy server to connect through. tls_connection_options (Optional[TlsConnectionOptions]): Optional `TlsConnectionOptions` for the Local to Proxy connection. Must be distinct from the `TlsConnectionOptions` provided to the HTTP connection. auth_type (HttpProxyAuthenticationType): Type of proxy authentication to use. auth_username (Optional[str]): Username to use when `auth_type` is :const:`HttpProxyAuthenticationType.Basic`. auth_password (Optional[str]): Username to use when `auth_type` is :const:`HttpProxyAuthenticationType.Basic`. connection_type (HttpProxyConnectionType): Type of proxy connection to make. Nrgrhrk auth_type auth_username auth_passwordconnection_typer2cf||_||_||_||_||_||_||_yr4)rgrhrkrGrHrIrJ)r8rgrhrkrGrHrIrJs r!r9zHttpProxyOptions.__init__s9# &<#"**.r ) rrrrrCrDr>r?rHr6r rr9rr r!rmrms.fKO:U:]:]0404rCrmr{rr r!res+%!WWNNN'W/J/Jd>>BQ1QhG$3G$TKN4KN\<^<8K@>K@\2+2B_,_DOnOB:J/:JzDR.DRNWgW* ' ?/?/DHAHAr