g-DdZddlZddlmZmZddlmZddlmZm Z m Z m Z m Z m Z mZmZmZmZmZmZddlmZmZddlmZmZdd lmZdd lmZmZdd lm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(dd l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3dd l4m5Z5ddl6m7Z7m8Z8ddl9m:Z:m;Z;ddlZ>ddl?m@Z@GddeZAGddeZBGddeZCGddZDGddZEddZFdZGy)zH h2/connection ~~~~~~~~~~~~~ An implementation of a HTTP/2 connection. N)EnumIntEnum)InvalidPaddingError) GoAwayFrameWindowUpdateFrame HeadersFrame DataFrame PingFramePushPromiseFrame SettingsFrameRstStreamFrame PriorityFrameContinuationFrame AltSvcFrameExtensionFrame)EncoderDecoder) HPACKErrorOversizedHeaderListError)H2Configuration) ErrorCodes_error_code_from_int) WindowUpdatedRemoteSettingsChanged PingReceivedPingAckReceivedSettingsAcknowledgedConnectionTerminatedPriorityUpdatedAlternativeServiceAvailableUnknownFrameReceived) ProtocolErrorNoSuchStreamErrorFlowControlErrorFrameTooLargeErrorTooManyStreamsErrorStreamClosedErrorStreamIDTooLowErrorNoAvailableStreamIDError RFC1122ErrorDenialOfServiceError) FrameBuffer)Settings SettingCodes)H2StreamStreamClosedBy) SizeLimitDictguard_increment_window) WindowManagerceZdZdZdZdZdZy)ConnectionStaterrN)__name__ __module__ __qualname__IDLE CLIENT_OPEN SERVER_OPENCLOSEDB/var/www/openai/venv/lib/python3.12/site-packages/h2/connection.pyr6r6(s DKK FrAr6c\eZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZy)ConnectionInputsrrr7r8 N)r9r:r; SEND_HEADERSSEND_PUSH_PROMISE SEND_DATA SEND_GOAWAYSEND_WINDOW_UPDATE SEND_PING SEND_SETTINGSSEND_RST_STREAM SEND_PRIORITY RECV_HEADERSRECV_PUSH_PROMISE RECV_DATA RECV_GOAWAYRECV_WINDOW_UPDATE RECV_PING RECV_SETTINGSRECV_RST_STREAM RECV_PRIORITYSEND_ALTERNATIVE_SERVICERECV_ALTERNATIVE_SERVICEr@rArBrDrD/slLIKIMOMLIKIMOM!!rArDceZdZdZdZy)AllowedStreamIDsrrN)r9r:r;EVENODDr@rArBrjrjFs D CrArjczeZdZdZiej ejfdejfej ejfdejfej ejfdej fej ejfdej fej ejfdej fej ejfdej fej ejfdej fej ej fdej fej ej"fdej$fej ej&fdej$fej ej(fdej fej ej*fdej fej ej,fdejfej ej.fdejfejejfdejfejej0fdejfejej"fdej$fiejejfdejfejejfdejfejejfdejfejej(fdejfejejfdejfejej2fdejfejej4fdejfejej&fdej$fejejfdejfejej fdejfejejfdejfejej6fdejfejej8fdejfejej*fdejfejej.fdejfejejfdejfejej:fdejfiejej0fdejfejej"fdej$fejejfdejfejejfdejfejejfdejfejej(fdejfejejfdejfejej4fdejfejej&fdej$fejejfdejfejej fdejfejejfdejfejej*fdejfejej6fdejfejej8fdejfejej,fdejfejej.fdejfej$ej"fdej$fej$ej&fdej$fiZdZdZ y)H2ConnectionStateMachinea7 A single HTTP/2 connection state machine. This state machine, while defined in its own class, is logically part of the H2Connection class also defined in this file. The state machine itself maintains very little state directly, instead focusing entirely on managing state transitions. Nc.tj|_yN)r6r<stateselfs rB__init__z!H2ConnectionStateMachine.__init__s$)) rAct|ts td |j|j|f\}}||_||SgS#t $r3|j}t j|_td|d|wxYw)z@ Process a specific input in the state machine. z-Input must be an instance of ConnectionInputszInvalid input z in state ) isinstancerD ValueError _transitionsrqKeyErrorr6r?r#)rsinput_func target_state old_states rB process_inputz&H2ConnectionStateMachine.process_inputs&"23LM M !%!2!2DJJ3G!H D,&DJv I  I(//DJ28)D  s A r[rdrYrbrZrcrXr?rar]rfrgrhrWr_r`r\rerVrxrtr~r@rArBrnrnKsI $u   /<<= ?.. /u   /<<= ?.. / u   /==> ?'' (u   /==> ?'' (u   /BBC ?'' (u   /BBC ?'' (u   /99: ?'' (u   /99: ?'' (#u$   /;;< ?)) *'u(   /;;< ?)) *+u,   /==> ?'' (/u0   /==> ?'' (3u4   /HHI ?.. /7u8   /HHI ?.. /;u@  $ $&6&C&CD ?.. /CuD  $ $&6&@&@A ?.. /GuH  $ $&6&B&BC ?)) *KuL  $ $&6&I&IJ ?.. /OuP  $ $&6&@&@A ?.. /SuT  $ $&6&D&DE ?.. /WuX  $ $&6&D&DE ?.. /[u\  $ $&6&C&CD ?.. /_u`  $ $&6&H&HI ?.. /cud  $ $&6&@&@A ?.. /guh  $ $&6&B&BC ?)) *kul  $ $&6&I&IJ ?.. /oup  $ $&6&@&@A ?.. /sut  $ $&6&D&DE ?.. /wux  $ $&6&F&FG ?.. /{u|  $ $&6&F&FG ?.. /u@  $ $&6&D&DE ?.. /CuD  $ $  5 5 7223IuN  $ $&6&C&CD ?.. /QuR  $ $&6&H&HI ?.. /UuV  $ $&6&@&@A ?.. /YuZ  $ $&6&B&BC ?)) *]u^  $ $&6&I&IJ ?.. /aub  $ $&6&@&@A ?.. /euf  $ $&6&D&DE ?.. /iuj  $ $&6&D&DE ?.. /mun  $ $&6&C&CD ?.. /qur  $ $&6&@&@A ?.. /uuv  $ $&6&B&BC ?)) *yuz  $ $&6&I&IJ ?.. /}u~  $ $&6&@&@A ?.. /AuB  $ $&6&D&DE ?.. /EuF  $ $&6&D&DE ?.. /IuJ  $ $&6&F&FG ?.. /MuN  $ $&6&F&FG ?.. /QuR  $ $  5 5 7223WuX  $ $  5 5 7223]ub   !1!=!=> ?)) *   !1!=!=> ?)) *iuLn*rArnceZdZdZdZdZdZdZdZdZ d;dZ dZ d Z e d Ze d Ze d Zd ZdZd;dZdZdZdZ ddZ d?dZdZ d@dZ dAdZ!dZ"dZ#d Z$d;d!Z%d"Z&d#Z'd$Z(d%Z)d&Z*d'Z+d(Z,d)Z-d*Z.d+Z/d,Z0d-Z1d.Z2d/Z3d0Z4d1Z5d2Z6d3Z7d4Z8d5Z9d6Z:d7Z;d8Zy)B H2Connectiona A low-level HTTP/2 connection object. This handles building and receiving frames and maintains both connection and per-stream state for all streams on this connection. This wraps a HTTP/2 Connection state machine implementation, ensuring that frames can only be sent/received when the connection is in a valid state. It also builds stream state machines on demand to ensure that the constraints of those state machines are met as well. Attempts to create frames that cannot be sent will raise a ``ProtocolError``. .. versionchanged:: 2.3.0 Added the ``header_encoding`` keyword argument. .. versionchanged:: 2.5.0 Added the ``config`` keyword argument. Deprecated the ``client_side`` and ``header_encoding`` parameters. .. versionchanged:: 3.0.0 Removed deprecated parameters and properties. :param config: The configuration for the HTTP/2 connection. .. versionadded:: 2.5.0 :type config: :class:`H2Configuration ` iiiiNct|_i|_d|_d|_t |_t|_|j|j_ ||_ |jtd|_ t|jjtj dtj"|ji|_t|jj |_|j&j(|_|j&j,|_|j$j,|_t3|jj |_g|_t9|_t=|j>|_ tC|j$j( |_"tF|jHtJ|jLtN|jPtR|jTtV|jXtZ|j\t^|j`tb|jdtf|jhtj|jltn|jptr|jti |_;y) NrT) client_sided)clientinitial_values)r)server) size_limit)max_window_size)> 477 t// t@@ t// D:: 477 33 t?? 44 D77 & "rAc|syxjdjd|Dz c_tfd|DsJy)NrAc3<K|]}|jywrp) serialize).0fs rB z4H2Connection._prepare_for_sending..s&Efq{{}fsc3PK|]}|jjkywrp)body_lenr)rrrss rBrz4H2Connection._prepare_for_sending..s!Nv!1::!=!==vs#&)rjoinall)rsframess` rB_prepare_for_sendingz!H2Connection._prepare_for_sendings=  chh&Ef&EEENvNNNNrAc8d}g}|jjD]=\}}|jr|dz|k(r|dz } |js-|j |?|D]6}|jj |}|j |j|<8|S)z A common method of counting number of open streams. Returns the number of streams that are open *and* that have (stream ID % 2) == remainder. While it iterates, also deletes any closed streams. rr7r)ritemsopenclosedappendpop closed_byr)rs remaindercount to_delete stream_idstreams rB _open_streamszH2Connection._open_streamss  !%!3!3!5 Iv{{ A  :   + "6 #I\\%%i0F.4.>.>D  +# rAcbt|jj}|j|S)z> The current number of open outbound streams. intrrr)rsoutbound_numberss rBopen_outbound_streamsz"H2Connection.open_outbound_streamss+ t{{667!!"233rAcdt|jj }|j|S)z= The current number of open inbound streams. r)rsinbound_numberss rBopen_inbound_streamsz!H2Connection.open_inbound_streamss, $++"9"99:!!/22rAc.|jjS)a7 The size of the inbound flow control window for the connection. This is rarely publicly useful: instead, use :meth:`remote_flow_control_window `. This shortcut is largely present to provide a shortcut to this data. )rcurrent_window_sizerrs rBinbound_flow_control_windowz(H2Connection.inbound_flow_control_windows88LLLrAc|jjjd||j|}|r |jn |j }||kr t |||dzt|k7r tdt||j|jj|jj}|jjjd||j|_ |j|_||j|<|jjjd|jj!|r ||_|S||_|S)z Initiate a new stream. .. versionchanged:: 2.0.0 Removed this function from the public API. :param stream_id: The ID of the stream to open. :param allowed_ids: What kind of stream ID is allowed. z#Attempting to initiate stream ID %dr7zInvalid stream ID for peer.)rinbound_window_sizeoutbound_window_sizezStream ID %d createdzCurrent streams: %s)rloggerdebug_stream_id_is_outboundrrr)rr#r0rrrrrrkeys)rsr allowed_idsoutboundhighest_stream_idss rB_begin_new_streamzH2Connection._begin_new_streamsJ   19 ..y9/7D + +  * *  ) )%i1BC C Mc+. .-   ;; $ 3 3 G G!%!5!5!I!I     !7C#'#>#> $($@$@!"# Y   !6 8I8I8KL .7D +.7D *rAc|jjjd|jj t j |jjrd}nd}td}|jjD]\}}||j|<|jjjd|j|xj||jzz c_ y)z Provides any data that needs to be sent at the start of the connection. Must be called for both clients and servers. zInitializing connectionsPRI * HTTP/2.0 SM rArzSend Settings frame: %sN)rrrrr~rDr[rr rrsettingsrr)rspreamblersettingvalues rBinitiate_connectionz H2Connection.initiate_connections   !:; (()9)G)GH ;; " ":HH ! "11779NGU"'AJJw :   %t':':  h66rAc|jjjd|jd}|j |jj rbt d}|jjD]\}}||j|<|j}tj|}nD|rBtj|}t d}|j||j||jj rtj ntj"}|jjjd||j$j'||j)dt*j,|j.dj1|jj |S)a Call to initialise the connection object for use with an upgraded HTTP/2 connection (i.e. a connection negotiated using the ``Upgrade: h2c`` HTTP header). This method differs from :meth:`initiate_connection ` in several ways. Firstly, it handles the additional SETTINGS frame that is sent in the ``HTTP2-Settings`` header field. When called on a client connection, this method will return a bytestring that the caller can put in the ``HTTP2-Settings`` field they send on their initial request. When called on a server connection, the user **must** provide the value they received from the client in the ``HTTP2-Settings`` header field to the ``settings_header`` argument, which will be used appropriately. Additionally, this method sets up stream 1 in a half-closed state appropriate for this side of the connection, to reflect the fact that the request is already complete. Finally, this method also prepares the appropriate preamble to be sent after the upgrade. .. versionadded:: 2.3.0 :param settings_header: (optional, server-only): The value of the ``HTTP2-Settings`` header field received from the client. :type settings_header: ``bytes`` :returns: For clients, a bytestring to put in the ``HTTP2-Settings``. For servers, returns nothing. :rtype: ``bytes`` or ``None`` z(Upgrade connection. Current settings: %sNrzProcess input %sr)rr)rrrrrrr rrserialize_bodybase64urlsafe_b64encodeurlsafe_b64decode parse_bodyrrDrUr^rr~rrjrlrupgrade)rssettings_header frame_datarrrconnection_inputs rBinitiate_upgrade_connectionz(H2Connection.initiate_upgrade_connectionsqB   68K8K     " ;; " "a A"&"5"5";";"=&+ 7##>))+J11*=J  %66GOa A LL )  ( ( + .2[[-D-D  ) )!..    !35EF (()9: 8H8L8LM Q 7 78rAcd |j|S#t$r|j||cYSwxYw)a Gets a stream by its stream ID. Will create one if one does not already exist. Use allowed_ids to circumvent the usual stream ID rules for clients and servers. .. versionchanged:: 2.0.0 Removed this function from the public API. )rryr)rsrrs rB_get_or_create_streamz"H2Connection._get_or_create_streamDs; B<< * * B)))[A A Bs //c |j|S#t$rG|j|}|r |jn |j}||kDr t |t |wxYw)aB Gets a stream by its stream ID. Raises NoSuchStreamError if the stream ID does not correspond to a known stream and is higher than the current maximum: raises if it is lower than the current maximum. .. versionchanged:: 2.0.0 Removed this function from the public API. )rryrrrr$r()rsrrrs rB_get_stream_by_idzH2Connection._get_stream_by_idRso 3<< * * 3229=H3;//..  ,,' 22' 22 3s AA!c|js|jjrdnd}n|jdz}|jjj d|||j kDr t d|S)a Returns an integer suitable for use as the stream ID for the next stream created by this endpoint. For server endpoints, this stream ID will be even. For client endpoints, this stream ID will be odd. If no stream IDs are available, raises :class:`NoAvailableStreamIDError `. .. warning:: The return value from this function does not change until the stream ID has actually been used by sending or pushing headers on that stream. For that reason, it should be called as close as possible to the actual use of the stream ID. .. versionadded:: 2.0.0 :raises: :class:`NoAvailableStreamIDError ` :returns: The next free stream ID this peer can use to initiate a stream. :rtype: ``int`` rr7zNext available stream ID %dzExhausted allowed stream IDs)rrrrrHIGHEST_ALLOWED_STREAM_IDr*)rsnext_stream_ids rBget_next_available_stream_idz)H2Connection.get_next_available_stream_idiso0.."&++"9"9QqN!<  D:: :*+IJ JrAc|jjjd|||jvrB|jj }|j dz|kDrtd||j fz|jjtj|j|t|jj}|j||j |} |duxs |duxs|du} | rR|jjs t#d| d} | j$j'dt)| |||| d<|j+| y)a Send headers on a given stream. This function can be used to send request or response headers: the kind that are sent depends on whether this connection has been opened as a client or server connection, and whether the stream was opened by the remote peer or not. If this is a client connection, calling ``send_headers`` will send the headers as a request. It will also implicitly open the stream being used. If this is a client connection and ``send_headers`` has *already* been called, this will send trailers instead. If this is a server connection, calling ``send_headers`` will send the headers as a response. It is a protocol error for a server to open a stream by sending headers. If this is a server connection and ``send_headers`` has *already* been called, this will send trailers instead. When acting as a server, you may call ``send_headers`` any number of times allowed by the following rules, in this order: - zero or more times with ``(':status', '1XX')`` (where ``1XX`` is a placeholder for any 100-level status code). - once with any other status header. - zero or one time for trailers. That is, you are allowed to send as many informational responses as you like, followed by one complete response and zero or one HTTP trailer blocks. Clients may send one or two header blocks: one request block, and optionally one trailer block. If it is important to send HPACK "never indexed" header fields (as defined in `RFC 7451 Section 7.1.3 `_), the user may instead provide headers using the HPACK library's :class:`HeaderTuple ` and :class:`NeverIndexedHeaderTuple ` objects. This method also allows users to prioritize the stream immediately, by sending priority information on the HEADERS frame directly. To do this, any one of ``priority_weight``, ``priority_depends_on``, or ``priority_exclusive`` must be set to a value that is not ``None``. For more information on the priority fields, see :meth:`prioritize `. .. warning:: In HTTP/2, it is mandatory that all the HTTP/2 special headers (that is, ones whose header keys begin with ``:``) appear at the start of the header block, before any normal headers. .. versionchanged:: 2.3.0 Added support for using :class:`HeaderTuple ` objects to store headers. .. versionchanged:: 2.4.0 Added the ability to provide priority keyword arguments: ``priority_weight``, ``priority_depends_on``, and ``priority_exclusive``. :param stream_id: The stream ID to send the headers on. If this stream does not currently exist, it will be created. :type stream_id: ``int`` :param headers: The request/response headers to send. :type headers: An iterable of two tuples of bytestrings or :class:`HeaderTuple ` objects. :param end_stream: Whether this headers frame should end the stream immediately (that is, whether no more data will be sent after this frame). Defaults to ``False``. :type end_stream: ``bool`` :param priority_weight: Sets the priority weight of the stream. See :meth:`prioritize ` for more about how this field works. Defaults to ``None``, which means that no priority information will be sent. :type priority_weight: ``int`` or ``None`` :param priority_depends_on: Sets which stream this one depends on for priority purposes. See :meth:`prioritize ` for more about how this field works. Defaults to ``None``, which means that no priority information will be sent. :type priority_depends_on: ``int`` or ``None`` :param priority_exclusive: Sets whether this stream exclusively depends on the stream given in ``priority_depends_on`` for priority purposes. See :meth:`prioritize ` for more about how this field workds. Defaults to ``None``, which means that no priority information will be sent. :type priority_depends_on: ``bool`` or ``None`` :returns: Nothing zSend headers on stream ID %dr#Max outbound streams is %d, %d openN&Servers SHOULD NOT prioritize streams.rPRIORITY)rrrrrmax_concurrent_streamsrr'rr~rDrUrrjr send_headersrr+flagsadd_add_frame_priorityr) rsrheaders end_streampriority_weightpriority_depends_onpriority_exclusivemax_open_streamsrrpriority_present headers_frames rBrzH2Connection.send_headerssgH   *I DLL (#33JJ **Q.2BB)9%t'A'ABC (()9)F)FG++ ' (?(?@ $$ T\\:  D ( -  , - t +  ;;**"#KLL"1IM    # #J /+#" F1I !!&)rAcV|jjjd|t|t|}|8t |t s t d|dks|dkDr td||dzz }|jjjd||||j|kDrtd ||j|fz||jkDrtd ||jfz|jjtj|j |j#||| }|j%||xj&|zc_|jjjd |j&|j&dk\sJy) a Send data on a given stream. This method does no breaking up of data: if the data is larger than the value returned by :meth:`local_flow_control_window ` for this stream then a :class:`FlowControlError ` will be raised. If the data is larger than :data:`max_outbound_frame_size ` then a :class:`FrameTooLargeError ` will be raised. h2 does this to avoid buffering the data internally. If the user has more data to send than h2 will allow, consider breaking it up and buffering it externally. :param stream_id: The ID of the stream on which to send the data. :type stream_id: ``int`` :param data: The data to send on the stream. :type data: ``bytes`` :param end_stream: (optional) Whether this is the last data to be sent on the stream. Defaults to ``False``. :type end_stream: ``bool`` :param pad_length: (optional) Length of the padding to apply to the data frame. Defaults to ``None`` for no use of padding. Note that a value of ``0`` results in padding of length ``0`` (with the "padding" flag set on the frame). .. versionadded:: 2.6.0 :type pad_length: ``int`` :returns: Nothing z%Send data on stream ID %d with len %dNzpad_length must be an intrz)pad_length must be within range: [0, 255]rz Frame size on stream ID %d is %dz0Cannot send %d bytes, flow control window is %d.z/Cannot send frame size %d, max frame size is %d) pad_lengthz'Outbound flow control window size is %d)rrrlenrvr TypeErrorrwlocal_flow_control_windowr%rr&rr~rDrWr send_datarr)rsrdatarr  frame_sizers rBrzH2Connection.send_datasD   3YD  Y  !j#. ;<<A~c!1 !LMM *q. (J   . :  66yA A"BT;;IFGH $66 6$AT99:;  (()9)C)CDi(22 *3  !!&) ))Z7)   5  - - 00A555rAc|jjjd||jj t j |j|j}|j|y)a Cleanly end a given stream. This method ends a stream by sending an empty DATA frame on that stream with the ``END_STREAM`` flag set. :param stream_id: The ID of the stream to end. :type stream_id: ``int`` :returns: Nothing zEnd stream ID %dN) rrrrr~rDrWrrr)rsrrs rBrzH2Connection.end_streamfs_   !3Y? (()9)C)CDi(335 !!&)rAcd|cxkr|jksntd|jz|jjtj |H|j |}|j|}|jjjd||nV|jj|td}||_|g}|jjjd||j|y)a Increment a flow control window, optionally for a single stream. Allows the remote peer to send more data. .. versionchanged:: 2.0.0 Rejects attempts to increment the flow control window by out of range values with a ``ValueError``. :param increment: The amount to increment the flow control window by. :type increment: ``int`` :param stream_id: (optional) The ID of the stream that should have its flow control window opened. If not present or ``None``, the connection flow control window will be opened instead. :type stream_id: ``int`` or ``None`` :returns: Nothing :raises: ``ValueError`` rz/Flow control increment must be between 1 and %dNz/Increase stream ID %d flow control window by %drz-Increase connection flow control window by %d)MAX_WINDOW_INCREMENTrwrr~rDrYrincrease_flow_control_windowrrrr window_openedrwindow_incrementr)rs incrementrrrrs rBincrement_flow_control_windowz*H2Connection.increment_flow_control_windowvs$Y;$";";;A))*  (()9)L)LM  \\),F88F KK   $ $A9   5 5 C CI N!!$A!*A SF KK   $ $?  !!&)rAc |jjjd||jjs t d|j jtj|j|}|dzdk(r t d|j|tj}||j|<|j|||j }|j#}|j%||zy)a  Push a response to the client by sending a PUSH_PROMISE frame. If it is important to send HPACK "never indexed" header fields (as defined in `RFC 7451 Section 7.1.3 `_), the user may instead provide headers using the HPACK library's :class:`HeaderTuple ` and :class:`NeverIndexedHeaderTuple ` objects. :param stream_id: The ID of the stream that this push is a response to. :type stream_id: ``int`` :param promised_stream_id: The ID of the stream that the pushed response will be sent on. :type promised_stream_id: ``int`` :param request_headers: The headers of the request that the pushed response will be responding to. :type request_headers: An iterable of two tuples of bytestrings or :class:`HeaderTuple ` objects. :returns: Nothing z'Send Push Promise frame on stream ID %dz$Remote peer has disabled stream pushr7r Cannot recursively push streams.N)rrrr enable_pushr#rr~rDrVrrrjrkrpush_stream_in_bandrlocally_pushedr)rsrpromised_stream_idrequest_headersr new_streamr new_framess rB push_streamzH2Connection.push_streams,   5y ##// FG G (()9)K)KL'' 2 Ma  BC C++  0 5 5 ,6 '(++   ..0  !!&:"56rAc@|jjjdt|trt |dk7rt d|z|jjtjtd}||_ |j|gy)z Send a PING frame. :param opaque_data: A bytestring of length 8 that will be sent in the PING frame. :returns: Nothing zSend Ping framerIzInvalid value for ping data: %rrN)rrrrvbytesr rwrr~rDrZr opaque_datar)rsr'rs rBpingzH2Connection.pings   !23+u-[1AQ1F>LM M (()9)C)CD aL#  !!1#&rAc|jjjd||jj t j |j|}|j|}|j|y)ai Reset a stream. This method forcibly closes a stream by sending a RST_STREAM frame for a given stream. This is not a graceful closure. To gracefully end a stream, try the :meth:`end_stream ` method. :param stream_id: The ID of the stream to reset. :type stream_id: ``int`` :param error_code: (optional) The error code to use to reset the stream. Defaults to :data:`ErrorCodes.NO_ERROR `. :type error_code: ``int`` :returns: Nothing zReset stream ID %dN) rrrrr~rDr\r reset_streamr)rsr error_coderrs rBr*zH2Connection.reset_streamsh"   !5yA (()9)I)IJ'' 2$$Z0 !!&)rAc.|jjjd|jj t j |t|tsJ| |j}td|||xsd}|j|gy)aH Close a connection, emitting a GOAWAY frame. .. versionchanged:: 2.4.0 Added ``additional_data`` and ``last_stream_id`` arguments. :param error_code: (optional) The error code to send in the GOAWAY frame. :param additional_data: (optional) Additional debug data indicating a reason for closing the connection. Must be a bytestring. :param last_stream_id: (optional) The last stream which was processed by the sender. Defaults to ``highest_inbound_stream_id``. :returns: Nothing zClose connectionNrrA)rlast_stream_idr+additional_data) rrrrr~rDrXrvr&rrr)rsr+r.r-rs rBclose_connectionzH2Connection.close_connections"   !34 (()9)E)EF  &ou5 55  !!;;N )!,3   !!1#&rAc |jjjd||jj t j |jj|td}||_ |j|gy)z Update the local settings. This will prepare and emit the appropriate SETTINGS frame. :param new_settings: A dictionary of {setting: new value} z Update connection settings to %srN) rrrrr~rDr[rupdater rr)rs new_settingsrs rBupdate_settingszH2Connection.update_settings%ss   .   (()9)G)GH ""<0 ! !  !!1#&rAcPt|ts td| | td|jj t j |td}||_||_ |g}n"|j|}|j|}|j|y)ai Notify a client about an available Alternative Service. An Alternative Service is defined in `RFC 7838 `_. An Alternative Service notification informs a client that a given origin is also available elsewhere. Alternative Services can be advertised in two ways. Firstly, they can be advertised explicitly: that is, a server can say "origin X is also available at Y". To advertise like this, set the ``origin`` argument and not the ``stream_id`` argument. Alternatively, they can be advertised implicitly: that is, a server can say "the origin you're contacting on stream X is also available at Y". To advertise like this, set the ``stream_id`` argument and not the ``origin`` argument. The explicit method of advertising can be done as long as the connection is active. The implicit method can only be done after the client has sent the request headers and before the server has sent the response headers: outside of those points, h2 will forbid sending the Alternative Service advertisement by raising a ProtocolError. The ``field_value`` parameter is specified in RFC 7838. h2 does not validate or introspect this argument: the user is required to ensure that it's well-formed. ``field_value`` corresponds to RFC 7838's "Alternative Service Field Value". .. note:: It is strongly preferred to use the explicit method of advertising Alternative Services. The implicit method of advertising Alternative Services has a number of subtleties and can lead to inconsistencies between the server and client. h2 allows both mechanisms, but caution is strongly advised. .. versionadded:: 2.3.0 :param field_value: The RFC 7838 Alternative Service Field Value. This argument is not introspected by h2: the user is responsible for ensuring that it is well-formed. :type field_value: ``bytes`` :param origin: The origin/authority to which the Alternative Service being advertised applies. Must not be provided at the same time as ``stream_id``. :type origin: ``bytes`` or ``None`` :param stream_id: The ID of the stream which was sent to the authority for which this Alternative Service advertisement applies. Must not be provided at the same time as ``origin``. :type stream_id: ``int`` or ``None`` :returns: Nothing. zField must be bytestring.Nz*Must not provide both origin and stream_idr)r) rvr&rwrr~rDrgroriginfieldradvertise_alternative_servicer)rs field_valuer5rrrrs rBr7z*H2Connection.advertise_alternative_service5sr+u-89 9  )"7IJ J ((  5 5   a(AAH!AGSF++I6F99+FF !!&)rAc|jjs td|jj t j t|}t||||}|j|gy)a Notify a server about the priority of a stream. Stream priorities are a form of guidance to a remote server: they inform the server about how important a given response is, so that the server may allocate its resources (e.g. bandwidth, CPU time, etc.) accordingly. This exists to allow clients to ensure that the most important data arrives earlier, while less important data does not starve out the more important data. Stream priorities are explained in depth in `RFC 7540 Section 5.3 `_. This method updates the priority information of a single stream. It may be called well before a stream is actively in use, or well after a stream is closed. .. warning:: RFC 7540 allows for servers to change the priority of streams. However, h2 **does not** allow server stacks to do this. This is because most clients do not adequately know how to respond when provided conflicting priority information, and relatively little utility is provided by making that functionality available. .. note:: h2 **does not** maintain any information about the RFC 7540 priority tree. That means that h2 does not prevent incautious users from creating invalid priority trees, particularly by creating priority loops. While some basic error checking is provided by h2, users are strongly recommended to understand their prioritisation strategies before using the priority tools here. .. note:: Priority information is strictly advisory. Servers are allowed to disregard it entirely. Avoid relying on the idea that your priority signaling will definitely be obeyed. .. versionadded:: 2.4.0 :param stream_id: The ID of the stream to prioritize. :type stream_id: ``int`` :param weight: The weight to give the stream. Defaults to ``16``, the default weight of any stream. May be any value between ``1`` and ``256`` inclusive. The relative weight of a stream indicates what proportion of available resources will be allocated to that stream. :type weight: ``int`` :param depends_on: The ID of the stream on which this stream depends. This stream will only be progressed if it is impossible to progress the parent stream (the one on which this one depends). Passing the value ``0`` means that this stream does not depend on any other. Defaults to ``0``. :type depends_on: ``int`` :param exclusive: Whether this stream is an exclusive dependency of its "parent" stream (i.e. the stream given by ``depends_on``). If a stream is an exclusive dependency of another, that means that all previously-set children of the parent are moved to become children of the new exclusively-dependent stream. Defaults to ``False``. :type exclusive: ``bool`` rN) rrr+rr~rDr]rrr)rsrweight depends_on exclusiveframes rB prioritizezH2Connection.prioritizesg@{{&&GH H ((  * * i(#E6:yI !!5'*rAcd|j|}t|j|jS)a1 Returns the maximum amount of data that can be sent on stream ``stream_id``. This value will never be larger than the total data that can be sent on the connection: even if the given stream allows more data, the connection window provides a logical maximum to the amount of data that can be sent. The maximum data that can be sent in a single data frame on a stream is either this value, or the maximum frame size, whichever is *smaller*. :param stream_id: The ID of the stream whose flow control window is being queried. :type stream_id: ``int`` :returns: The amount of data in bytes that can be sent on the stream before the flow control window is exhausted. :rtype: ``int`` )rminrrsrrs rBrz&H2Connection.local_flow_control_windows3*'' 2  - -  / /  rAcd|j|}t|j|jS)a= Returns the maximum amount of data the remote peer can send on stream ``stream_id``. This value will never be larger than the total data that can be sent on the connection: even if the given stream allows more data, the connection window provides a logical maximum to the amount of data that can be sent. The maximum data that can be sent in a single data frame on a stream is either this value, or the maximum frame size, whichever is *smaller*. :param stream_id: The ID of the stream whose flow control window is being queried. :type stream_id: ``int`` :returns: The amount of data in bytes that can be received on the stream before the flow control window is exhausted. :rtype: ``int`` )rr@rrAs rBremote_flow_control_windowz'H2Connection.remote_flow_control_windows3*'' 2  , ,  . .  rAc|jjjd|||dkrtd|z|dkr tdg}|j}|j |}|r#t d}||_|j| |j|}|jr!|j|j| |j|y#t$rYwxYw)a Inform the :class:`H2Connection ` that a certain number of flow-controlled bytes have been processed, and that the space should be handed back to the remote peer at an opportune time. .. versionadded:: 2.5.0 :param acknowledged_size: The total *flow-controlled size* of the data that has been processed. Note that this must include the amount of padding that was sent with that data. :type acknowledged_size: ``int`` :param stream_id: The ID of the stream on which this data was received. :type stream_id: ``int`` :returns: Nothing :rtype: ``None`` z.Ack received data on stream ID %d with size %drz7Stream ID %d is not valid for acknowledge_received_dataz Cannot acknowledge negative dataN)rrrrwr process_bytesrrrrrextendacknowledge_received_datar(r)rsacknowledged_sizerr conn_managerconn_incrementrrs rBrGz&H2Connection.acknowledge_received_datas$   < (  >I  q ?@ @@@ %334EF !!$A!/A  MM!  ++I6F{{ 445FG !!&)!   sC C,+C,c|&t|j}t|_|St|jd|}|j|d|_|S)a| Returns some data for sending out of the internal data buffer. This method is analogous to ``read`` on a file-like object, but it doesn't block. Instead, it returns as much data as the user asks for, or less if that much data is not available. It does not perform any I/O, and so uses a different name. :param amount: (optional) The maximum amount of data to return. If not set, or set to ``None``, will return as much data as possible. :type amount: ``int`` :returns: A bytestring containing the data to send on the wire. :rtype: ``bytes`` N)r&rr)rsamountrs rB data_to_sendzH2Connection.data_to_send<sY >++,D!*D K++GV45D!%!3!3FG!`, that call would return no data. This method should not normally be used, but is made available to avoid exposing implementation details. N)rrrrs rBclear_outbound_data_bufferz'H2Connection.clear_outbound_data_bufferTs'[rAc|jjtj|jj }t j|vr9|t j}|j|j|jt j|vr.|t j}|j|j_ t j|vrT|t j}|j|_|j j#D]}|j|_t%d}|j&j)d|gS)z Acknowledge settings that have been received. .. versionchanged:: 2.0.0 Removed from public API, removed useless ``event`` parameter, made automatic. :returns: Nothing rACK)rr~rDr[r acknowledger/INITIAL_WINDOW_SIZE"_flow_control_change_from_settingsoriginal_value new_valueHEADER_TABLE_SIZErheader_table_sizeMAX_FRAME_SIZErrvaluesr rr)rschangesrrrs rB_acknowledge_settingsz"H2Connection._acknowledge_settings`s (()9)G)GH&&224  + +w 6l>>?G  3 3&&!!   ) )W 4l<<=G-4->->DLL *  & &' 1l99:G+2+<+I%ll))+F2H333F /,rAcn||z }|jjD]}|j|y)a Update remote flow control windows in response to a change in the value of SETTINGS_INITIAL_WINDOW_SIZE. When this setting is changed, it automatically updates all remote flow control windows by the delta in the settings values. N)rrZ*_inbound_flow_control_change_from_settingsr^s rBrbz7H2Connection._inbound_flow_control_change_from_settingss3I%ll))+F  = =e D,rAc|jjjd|g}|jj ||j |j_ |jD]"}|j|j|$ |S#t$r+|jtjtdt$r!}|j|jd}~wwxYw)a Pass some received HTTP/2 data to the connection for handling. :param data: The data received from the remote peer on the network. :type data: ``bytes`` :returns: A list of events that the remote peer triggered by sending this data. z6Process received data on connection. Received data: %rz$Received frame with invalid padding.N)rrtraceradd_datarrrF_receive_framer_terminate_connectionrPROTOCOL_ERRORr#r+)rsreventsr=es rB receive_datazH2Connection.receive_datas   Dd  %%d+.2.I.I+ -- d11%89. # H  & &z'@'@ A FG G   & &q|| 4   s 1B;C0C++C0c|jjjdt| |j|j |\}}|j ||S#t$rl}|j|jrEt|j}|j|_ |j |g|j}nYd}~|Sd}~wt$r}|j|jr?t|j}tj|_ |j |gg}n1|j!|jrt|jYd}~|Sd}~wwxYw)z Handle a frame received on the connection. .. versionchanged:: 2.0.0 Removed from the public API. zReceived frame: %sN)rrrdreprr __class__rr(_stream_is_closed_by_resetrr r+_eventsr)r STREAM_CLOSED_stream_is_closed_by_end)rsr=rrirjrs rBrfzH2Connection._receive_framesF   !5tE{C$ .HT77HONFFD  % %f - G! ..q{{;"1;;/ || ))1#.6 1# ..q{{;"1;;/)77 ))1#...q{{;' 44 1 s%"A&& E8/A!C E8"B E33E8ctd}|j|_||_|jj t j|j|gy)zn Terminate the connection early. Used in error handling blocks to send GOAWAY frames. rN) rrr-r+rr~rDrXr)rsr+rs rBrgz"H2Connection._terminate_connectionsM N99!  (()9)E)EF !!1#&rAc|j|jvrB|jj}|jdz|kDrt d||j fzt|j|j}|jjtj}|j|jt|j j" }|j%|d|j&v|j j(\}}d|j&vr6|j+|\}} | d|d_|j/| |rJ|||zfS)z< Receive a headers frame on the connection. rr END_STREAMrr)rrrrrr'r_decode_headersrrrr~rDr^rrjrrreceive_headersrheader_encodingrpriority_updatedrF) rsr=rrrirr stream_eventsp_framesp_eventss rBrz#H2Connection._receive_headers_framesN ??$,, .#22II ))A-1AA)9%t'A'ABC"$,, ;##11  ) ) ++ OO-$++2I2I.IJ !' 6 6  EKK ' KK ' '!   $!%!=!=e!D Hh08 M!  -   * <v ---rAc|jjs tdt|j|j }|j jtj} |j|j}|jdzdk(r td |j+|j"||j,j.\}}|j3|j"t4j6}||j8|j"<|j;||||zfS#t$ri|j|jtjk(r1t!|j"}t$j&|_|g|fcYStdwxYw#t0$r2t!|j"}t$j&|_|g|fcYSwxYw)zA Receive a push-promise frame on the connection. zReceived pushed streamz#Attempted to push on closed stream.r7rr)rrr#rvrrrr~rDr_rrr$_stream_closed_byr1r\r r rREFUSED_STREAMr+receive_push_promise_in_bandrrxr(rrjrkrremotely_pushed) rsr=pushed_headersrirrrrzr"s rBrz(H2Connection._receive_push_promise_frame's"".. 89 9(uzzB##11  . .  G++EOO2v ---]! G&&u7"223"5#;#;<)88 sF{" EF F! G@! u778A%44AL3;   s%,D4%4F)4A$F& F&)8G$#G$cg}|j}|j|j}|rTtd}||_|j ||j jjd|j|t|j}|j|_ |j ||j jjd|jz|||jzfS)NrzLReceived DATA frame on closed stream %d - auto-emitted a WINDOW_UPDATE by %dzAStream %d already CLOSED or cleaned up - auto-emitted a RST_FRAME) rrEflow_controlled_lengthrrrrrrrr r+rp)rsriexcr=rrIrJrs rB_handle_data_on_closed_streamz*H2Connection._handle_data_on_closed_streamfs @@ %33  ( (  !!$A!/A  MM!  KK   $ $5  3== )~~  a    '). 9 v +++rAc|j}|jjtj}|j j | |j|j}|j|jd|jv|\}}|||zfS#t$r}|j|||cYd}~Sd}~wwxYw)z9 Receive a data frame on the connection. ruN)rrr~rDr`rwindow_consumedrrrkrrr(r)rsr=rrirrrzrjs rBrz H2Connection._receive_data_frames"'!=!=##11  & &  11AA "  H++EOO+>u+E (M=f}444! MM sA!! A10A1c|jjtj}t }|j |_|j |_|j|_|jdz|_ |j |j k(rtd|j z|j|g|fS)z= Receive a PRIORITY frame on the connection. r"Stream %d may not depend on itself) rr~rDrfr rr;r< stream_weightr:r#r)rsr=rievents rBrz$H2Connection._receive_priority_frames##11  * *  !// ++//**Q.    u .4uF   e6zrAcF|jjtj}|j t }t |j|_|j|_|jr |jnd|_ |j|g|fS)z; Receive a GOAWAY frame on the connection. N) rr~rDrarOrrr+r-r.r)rsr=ri new_events rBrz"H2Connection._receive_goaway_frame!s##11  ( (  ''))* 3E4D4DE #(#7#7  (-(=(=&+%:%:CG ! i 6zrAcf|j|j}|jJd)a  A naked CONTINUATION frame has been received. This is always an error, but the type of error it is depends on the state of the stream and must transition the state of the stream, so we need to pass it to the appropriate stream. zShould not be reachable)rrreceive_continuation)rsr=rs rBrz(H2Connection._receive_naked_continuation6s/''8##%///urAc"|jjtj}g}|jrV |j |j}|j |\}}|j||j|||fS|js||fS|jjs||fSt}|j|_ |j|_|j!|||fS#ttf$rY||fSwxYw)a> An ALTSVC frame has been received. This frame, specified in RFC 7838, is used to advertise alternative places where the same service can be reached. This frame can optionally be received either on a stream or on stream 0, and its semantics are different in each case. )rr~rDrhrrreceive_alt_svcrFr$r(r5rrr!r6r8r)rsr=rirrrrzrs rBrz#H2Connection._receive_alt_svc_frameAs ##11  5 5  ??  -//@06/E/Ee/L, } m, m,"v~<<v~%;;**v~%/1E <>?G  ; ;&&!!   , , 7l??@G070A0ADLL -  & &' 1l99:G*1*;*;D '  ) )W 4l<<=G3:2C2CDLL /rAcL|dzt|jjk(S)z Returns ``True`` if the stream ID corresponds to an outbound stream (one initiated by this peer), returns ``False`` otherwise. r7)rrrrsrs rBrz#H2Connection._stream_id_is_outbounds" A T[[%<%rAc||jvr|j|jS||jvr|j|Sy)a' Returns how the stream was closed. The return value will be either a member of ``h2.stream.StreamClosedBy`` or ``None``. If ``None``, the stream was closed implicitly by the peer opening a stream with a higher stream ID before opening this one. N)rrrrs rBr~zH2Connection._stream_closed_bysG  $<< *44 4 ,, ,'' 2 2rAcd|j|tjtjfvS)z Returns ``True`` if the stream was closed by sending or receiving a RST_STREAM frame. Returns ``False`` otherwise. )r~r1rer\rs rBroz'H2Connection._stream_is_closed_by_resets2 %%i0  * *N,J,J5   rAcd|j|tjtjfvS)z Returns ``True`` if the stream was closed by sending or receiving an END_STREAM flag in a HEADERS or DATA frame. Returns ``False`` otherwise. )r~r1RECV_END_STREAMSEND_END_STREAMrs rBrrz%H2Connection._stream_is_closed_by_ends2 %%i0  * *N,J,J5   rArp)FNNN)FN)r)rNN)NNNNN)?r9r:r;rDEFAULT_MAX_OUTBOUND_FRAME_SIZEDEFAULT_MAX_INBOUND_FRAME_SIZErrrrrtrrpropertyrrrrrrrrrrrrrr$r(r*r/r3r7r>rrCrGrMrOr\rTrbrkrfrgrrrrrrrrrrrrrrrr~rorrr@rArBrrs:',#&+"!*%$) a FO *4433MM-^7*GR B3."H;@?C(,M*^H6T* .*`17f'$*.>B(,!'F'$.204M*^=A!J+X 6 64*l0 )#J$ EB.` '%.N=.~,:.66!.F25$4* 0+Z":?   rArc||jk(rtd|jz||dkDs|dkrtd|z|dz}||nd}||nd}||nd}||_||_||_|S)a6 Adds priority data to a given frame. Does not change any flags set on that frame: if the caller is adding priority information to a HEADERS frame they must set that themselves. This method also deliberately sets defaults for anything missing. This method validates the input values. rrz(Weight must be between 1 and 256, not %drPrF)rr#rr;r<)r=r:r;r<s rBrrsU__$ 05?? B   C<6A::VC  aKF)VrF)51J&2 I E!EEO LrAc |j|dS#t$r}td|zd}~wttt t f$r}td|zd}~wwxYw)z Decode a HPACK-encoded header block, translating HPACK exceptions into sensible h2 errors. This only ever returns bytestring headers: h2 may emit them as unicode later, but internally it processes them as bytestrings only. T)rawzOversized header block: %sNzError decoding header block: %s)decoderr,r IndexErrorrUnicodeDecodeErrorr#)rencoded_header_blockrjs rBrvrvsh C~~2~== #E##?!#CDD  I/A BC=ABB Cs A,AAAr)Hrrenumrrhyperframe.exceptionsrhyperframe.framerrrr r r r r rrrr hpack.hpackrrhpack.exceptionsrrrrerrorsrrrirrrrrrr r!r" exceptionsr#r$r%r&r'r(r)r*r+r, frame_bufferr-rr.r/rr0r1 utilitiesr2r3windowsr4r6rDrjrnrrrvr@rArBrs 5 )A#4  &,,<"d"t". w aaHT T n6$NCrA