g&dZddlmZmZddlmZddlmZmZm Z m Z m Z m Z m Z ddlmZmZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZddl m!Z!m"Z"m#Z#m$Z$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0Gd d eZ1Gd deZ2GddeZ3e4de5e1Dcgc]}dc}Z6de6e1jn<de6e1jp<de6e1jr<GddZ:ie1jve2jxfe:jze1jnfe1jve2j|fe:j~e1jnfe1jve2jfe:je1jfe1jve2jfe:je1jfe1jve2jfe:je1jfe1jve2jfde1jvfe1jve2jfe:jze1jpfe1jve2jfe:j~e1jrfe1je2jxfe:je1jrfe1je2jfe:je1jfe1je2jfde1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfde1jfe1je2j|fe:je1jpfie1je2jfe:je1jfe1je2jfde1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1jne2jxfe:je1jnfe1jne2j|fe:je1jnfe1jne2jfde1jnfe1jne2jfe:je1jnfe1jne2jfde1jpfe1jne2jfe:je1jrfe1jne2jfde1jnfe1jne2jfe:je1jnfe1jne2jfe:je1jfe1jne2jfe:je1jfe1jne2jfe:je1jnfie1jne2jfe:je1jnfe1jne2jfe:je1jnfe1jne2jfe:je1jnfe1jne2jfe:je1jnfe1jne2jfe:je1jnfe1jre2jxfe:je1jrfe1jre2j|fe:je1jfe1jre2jfde1jrfe1jre2jfe:je1jfe1jre2jfe:je1jfe1jre2jfde1jrfe1jre2jfe:je1jrfe1jre2jfe:je1jfe1jre2jfe:je1jfe1jre2jfe:je1jrfe1jre2jfe:je1jfe1jre2jfe:je1jrfie1jre2jfe:je1jrfe1jre2jfe:je1jrfe1jpe2j|fe:je1jpfe1jpe2jfe:je1jpfe1jpe2jfe:je1jfe1jpe2jfde1jpfe1jpe2jfe:je1jpfe1jpe2jfe:je1jfe1jpe2jfe:je1jfe1jpe2jfe:je1jpfe1jpe2jfe:je1jpfe1jpe2jfe:je1jpfe1jpe2jfe:je1jpfe1je2jfde1jfe1je2jfde1jfe1je2j|fe:je1jfe1je2jfe:je1jfe1je2jfde1jfe1je2jfde1jfe1je2jfe:je1jfe1je2jxfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfe1je2jfe:je1jfi ZiGddZjdZkycc}w)z< h2/stream ~~~~~~~~~ An implementation of a HTTP/2 stream. )EnumIntEnum) HeaderTuple) HeadersFrameContinuationFrame DataFrameWindowUpdateFrameRstStreamFramePushPromiseFrame AltSvcFrame) ErrorCodes_error_code_from_int)RequestReceivedResponseReceived DataReceived WindowUpdated StreamEndedPushedStreamReceived StreamResetTrailersReceivedInformationalResponseReceivedAlternativeServiceAvailable _ResponseSent _RequestSent _TrailersSent_PushedRequestSent) ProtocolErrorStreamClosedErrorInvalidBodyLengthErrorFlowControlError) guard_increment_windowis_informational_responseauthority_from_headersvalidate_headersvalidate_outbound_headersnormalize_outbound_headersHeaderValidationFlagsextract_method_headernormalize_inbound_headers) WindowManagerc(eZdZdZdZdZdZdZdZdZ y) StreamStaterr N) __name__ __module__ __qualname__IDLERESERVED_REMOTERESERVED_LOCALOPENHALF_CLOSED_REMOTEHALF_CLOSED_LOCALCLOSED>/var/www/openai/venv/lib/python3.12/site-packages/h2/stream.pyr-r-!s' DON D Fr>r-cXeZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZy) StreamInputsrr r.r/r0r1r2 N)r3r4r5 SEND_HEADERSSEND_PUSH_PROMISESEND_RST_STREAM SEND_DATASEND_WINDOW_UPDATESEND_END_STREAM RECV_HEADERSRECV_PUSH_PROMISERECV_RST_STREAM RECV_DATARECV_WINDOW_UPDATERECV_END_STREAMRECV_CONTINUATIONSEND_INFORMATIONAL_HEADERSRECV_INFORMATIONAL_HEADERSSEND_ALTERNATIVE_SERVICERECV_ALTERNATIVE_SERVICEUPGRADE_CLIENTUPGRADE_SERVERr=r>r?rArA+sjLOIOLOIO!#!#!!NNr>rAceZdZdZdZdZdZy)StreamClosedByrr r.r/N)r3r4r5rSrYrPrVr=r>r?rbrbAsOOOOr>rbFTceZdZdZdZdZdZdZdZdZ dZ d Z d Z d Z d Zd ZdZdZdZdZdZdZdZdZdZdZdZdZdZdZy)H2StreamStateMachinea A single HTTP/2 stream state machine. This stream object implements basically the state machine described in RFC 7540 section 5.1. :param stream_id: The stream ID of this stream. This is stored primarily for logging purposes. ctj|_||_d|_d|_d|_d|_d|_d|_ y)N) r-r6state stream_idclient headers_sent trailers_sentheaders_receivedtrailers_receivedstream_closed_by)selfrgs r?__init__zH2StreamStateMachine.__init__]sK %% " !! $!%!%r>ct|ts td t|j|f\}}|j}||_| |||SgS#t $rt j|_t$r%}t j|_t |d}~wwxYw#t$r3|j}t j|_t d|d|wxYw)z@ Process a specific input in the state machine. z)Input must be an instance of StreamInputsNzInvalid input z in state ) isinstancerA ValueError _transitionsrfrr-r<AssertionErrorKeyError)rninput_func target_stateprevious_statee old_states r? process_inputz"H2StreamStateMachine.process_inputms&,/HI I !-tzz6.B!C D,"ZZN%DJ+n55I%!,!3!3DJ%+!,!3!3DJ'**+  I$++DJ28)D  s#B% A'B"= BB"%c|js9|jdus |j tdd|_t}|gS|jrJd|_t }|gS)z{ Fires when something that should be a response is sent. This 'response' may actually be trailers. TzClient cannot send responses.)rirhrrrjrr~s r? response_sentz"H2StreamStateMachine.response_sentsm   {{d"dkk&9#$CDD $D !OE w )) ))!%D !OEwr>c|jrJ|jrJd|_d|_t}|j|_|gS)z3 Fires when a request is received. FT)rkrlrhrrgr~s r?request_receivedz%H2StreamStateMachine.request_receivedsK(((()))) $!..wr>c|js"|jdusJd|_t}n|jrJd|_t }|j |_|gS)zo Fires when a response is received. Also disambiguates between responses and trailers. T)rkrhrrlrrgr~s r?response_receivedz&H2StreamStateMachine.response_receiveds` $$;;$& &&$(D !$&E-- --%)D "$&E..wr>cl|js tdt}|j|_|gS)z. Fires when data is received. z"cannot receive data before headers)rkrrrgr~s r? data_receivedz"H2StreamStateMachine.data_receiveds2$$ DE E..wr>c>t}|j|_|gS)z? Fires when a window update frame is received. )rrgr~s r?window_updatedz#H2StreamStateMachine.window_updateds..wr>c>t}|j|_|gS)z Fires when an END_STREAM flag is received in the OPEN state, transitioning this stream to a HALF_CLOSED_REMOTE state. )rrgr~s r?stream_half_closedz'H2StreamStateMachine.stream_half_closeds  ..wr>chtj|_t}|j|_|gS)z7 Fires when a stream is cleanly ended. )rbrYrmrrgr~s r? stream_endedz!H2StreamStateMachine.stream_ended+!/ > > ..wr>chtj|_t}|j|_|gS)z: Fired when a stream is forcefully reset. )rbrVrmrrgr~s r? stream_resetz!H2StreamStateMachine.stream_resetrr>c>|jJd|_d|_gS)z Fires on the newly pushed stream, when pushed by the local peer. No event here, but definitionally this peer must be a server. FT)rhrkrnrys r?send_new_pushed_streamz+H2StreamStateMachine.send_new_pushed_streams( {{""" $ r>c>|jJd|_d|_gS)z Fires on the newly pushed stream, when pushed by the remote peer. No event here, but definitionally this peer must be a client. T)rhrirs r?recv_new_pushed_streamz+H2StreamStateMachine.recv_new_pushed_streams( {{"""   r>cN|jdur tdt}|gS)z Fires on the already-existing stream when a PUSH_PROMISE frame is sent. We may only send PUSH_PROMISE frames if we're a server. Tz&Cannot push streams from client peers.)rhrrr~s r?send_push_promisez&H2StreamStateMachine.send_push_promises+ ;;$  HI I"$wr>c|js&|j d}t|d}t|t}|j|_|gS)z Fires on the already-existing stream when a PUSH_PROMISE frame is received. We may only receive PUSH_PROMISE frames if we're a client. Fires a PushedStreamReceived event. z"Idle streams cannot receive pushesz)Cannot receive pushed streams as a server)rhrrrgparent_stream_id)rnrymsgrs r?recv_push_promisez&H2StreamStateMachine.recv_push_promisesU{{{{": $ $B$ $$&!%wr>c.tj|_y)zl Called when an attempt is made to send END_STREAM in the HALF_CLOSED_REMOTE state. N)rbrSrmrs r?send_end_streamz$H2StreamStateMachine.send_end_stream% !/ > >r>c.tj|_y)zi Called when an attempt is made to send RST_STREAM in a non-closed stream state. N)rbrPrmrs r?send_reset_streamz&H2StreamStateMachine.send_reset_stream,rr>ctj|_t|j}t }|j|_t j|_d|_ |g|_ |)a Called when we need to forcefully emit another RST_STREAM frame on behalf of the state machine. If this is the first time we've done this, we should also hang an event off the StreamClosedError so that the user can be informed. We know it's the first time we've done this if the stream is currently in a state other than CLOSED. F) rbrPrmrrgrr STREAM_CLOSED error_code remote_reset_events)rnryerrorrs r?reset_stream_on_errorz*H2StreamStateMachine.reset_stream_on_error3sV!/ > >!$..1 ..%33"  r>c,t|j)aw Called when an unexpected frame is received on an already-closed stream. An endpoint that receives an unexpected frame should treat it as a stream error or connection error with type STREAM_CLOSED, depending on the specific frame. The error handling is done at a higher level: this just raises the appropriate error. rrgrs r?recv_on_closed_streamz*H2StreamStateMachine.recv_on_closed_streamH //r>c,t|j)a[ Called when an attempt is made to send data on an already-closed stream. This essentially overrides the standard logic by throwing a more-specific error: StreamClosedError. This is a ProtocolError, so it matches the standard API of the state machine, but provides more detail to the user. rrs r?send_on_closed_streamz*H2StreamStateMachine.send_on_closed_streamTrr>c|jJ|jtjk(rt|jt d)a Called when a PUSH_PROMISE frame is received on a full stop stream. If the stream was closed by us sending a RST_STREAM frame, then we presume that the PUSH_PROMISE was in flight when we reset the parent stream. Rathen than accept the new stream, we just reset it. Otherwise, we should call this a PROTOCOL_ERROR: pushing a stream on a naturally closed stream is a real problem because it creates a brand new stream that the remote peer now believes exists. #Attempted to push on closed stream.)rmrbrPrrgrrs r?recv_push_on_closed_streamz/H2StreamStateMachine.recv_push_on_closed_stream`sE$$000  N$B$B B#DNN3 3 EF Fr>ctd)a Called when an attempt is made to push on an already-closed stream. This essentially overrides the standard logic by providing a more useful error message. It's necessary because simply indicating that the stream is closed is not enough: there is now a new stream that is not allowed to be there. The only recourse is to tear the whole connection down. r)rrs r?send_push_on_closed_streamz/H2StreamStateMachine.send_push_on_closed_streamssABBr>cJ|jr tdt}|gS)z Called when an informational header block is sent (that is, a block where the :status header has a 1XX value). Only enforces that these are sent *before* final headers are sent. z)Information response after final response)rirrr~s r?send_informational_responsez0H2StreamStateMachine.send_informational_responses'    KL Lwr>cl|jr tdt}|j|_|gS)z Called when an informational header block is received (that is, a block where the :status header has a 1XX value). z+Informational response after final response)rkrrrgr~s r?recv_informational_responsez0H2StreamStateMachine.recv_informational_responses3   MN N-/..wr>cT|jdurgS|jrgStgS)ae Called when receiving an ALTSVC frame. RFC 7838 allows us to receive ALTSVC frames at any stream state, which is really absurdly overzealous. For that reason, we want to limit the states in which we can actually receive it. It's really only sensible to receive it after we've sent our own headers and before the server has sent its header block: the server can't guarantee that we have any state around after it completes its header block, and the server doesn't know what origin we're talking about before we've sent ours. For that reason, this function applies a few extra checks on both state and some of the little state variables we keep around. If those suggest an unreasonable situation for the ALTSVC frame to have been sent in, we quietly ignore it (as RFC 7838 suggests). This function is also *not* always called by the state machine. In some states (IDLE, RESERVED_LOCAL, CLOSED) we don't bother to call it, because we know the frame cannot be valid in that state (IDLE because the server cannot know what origin the stream applies to, CLOSED because the server cannot assume we still have state around, RESERVED_LOCAL because by definition if we're in the RESERVED_LOCAL state then *we* are the server). F)rhrkrrs r? recv_alt_svcz!H2StreamStateMachine.recv_alt_svcs36 ;;% I  I,-..r>c2|jr tdy)a Called when sending an ALTSVC frame on this stream. For consistency with the restrictions we apply on receiving ALTSVC frames in ``recv_alt_svc``, we want to restrict when users can send ALTSVC frames to the situations when we ourselves would accept them. That means: when we are a server, when we have received the request headers, and when we have not yet sent our own response headers. z2Cannot send ALTSVC after sending response headers.N)rirrs r? send_alt_svcz!H2StreamStateMachine.send_alt_svcs"   D  r>N)r3r4r5__doc__ror|rrrrrrrrrrrrrrrrrrrrrrrrr=r>r?rdrdSs% <" "   $??* 0 0G& C  &/Pr>rdNceZdZdZdZdZedZedZedZ edZ dZ d!d Z d Z d Zd"d ZdZdZdZdZdZdZdZdZdZdZd#dZdZdZdZdZdZdZ dZ!d Z"y )$H2Streamaf A low-level HTTP/2 stream object. This handles building and receiving frames and maintains per-stream state. This wraps a HTTP/2 Stream state machine implementation, ensuring that frames can only be sent/received when the stream is in a valid state. Attempts to create frames that cannot be sent will raise a ``ProtocolError``. ct||_||_d|_d|_||_t ||_d|_d|_ d|_ ||_ y)Nr) rd state_machinergmax_outbound_frame_sizerequest_methodoutbound_flow_control_windowr+_inbound_window_manager_expected_content_length_actual_content_length _authorityconfig)rnrgrinbound_window_sizeoutbound_window_sizes r?rozH2Stream.__init__si 2)<"'+$"-A)(55H'I$)-%'(# r>ctdt|j|j|jjfzS)Nz<%s id:%d state:%r>)typer3rgrrfrns r?__repr__zH2Stream.__repr__ s7$ J   NN    $ $(   r>c.|jjS)a+ The size of the inbound flow control window for the stream. 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_sizers r?inbound_flow_control_windowz$H2Stream.inbound_flow_control_windows++???r>c<t|jjS)z Whether the stream is 'open' in any sense: that is, whether it counts against the number of concurrent streams. ) STREAM_OPENrrfrs r?openz H2Stream.opens4--3344r>cP|jjtjk(S)z/ Whether the stream is closed. )rrfr-r<rs r?closedzH2Stream.closed's! !!'';+=+===r>c.|jjS)zN Returns how the stream was closed, as one of StreamClosedBy. )rrmrs r? closed_byzH2Stream.closed_by.s !!222r>c|jjjd||jdk(sJ|rtj ntj }|jj|y)z Called by the connection to indicate that this stream is the initial request/response of an upgraded connection. Places the stream into an appropriate state. z Upgrading %rr N) rloggerdebugrgrAr_r`rr|)rn client_sidervs r?upgradezH2Stream.upgrade5sb   6~~"""+6L ' ',,  ((0r>c|jjjd||tj}|j j s(t|r|r tdtj}|j j|}t|j}|j|}|j||||}|rG|j jtj|dj j#d|j j$r |s td|j j r|j&t)||_t+||_|S)zn Returns a list of HEADERS/CONTINUATION frames to emit as either headers or trailers. zSend headers %s on %rz1Cannot set END_STREAM on informational responses.r END_STREAMz"Trailers must have END_STREAM set.)rrrrArNrrhr#rr[r|rrg_build_hdr_validation_flags_build_headers_framesrSflagsaddrjrr$r)r) rnheadersencoder end_streamrveventshfhdr_validation_flagsframess r? send_headerszH2Stream.send_headersGs@   !8'4H**##**)'2#G"<c&|jjjd||jj t j }t|j}||_ |j|}|j||||}|S)z Returns a list of PUSH_PROMISE/CONTINUATION frames to emit as a pushed stream header. Called on the stream that has the PUSH_PROMISE frame sent on it. zPush stream %r) rrrrr|rArOr rgpromised_stream_idrr)rnrelated_stream_idrrrppfrrs r?push_stream_in_bandzH2Stream.push_stream_in_bandxs   !148 ##11  * * t~~.!2#??G++ Wc#7  r>c`|jjtj}|rJgS)z Mark this stream as one that was pushed by this peer. Must be called immediately after initialization. Sends no frames, simply updates the state machine. )rr|rArO)rnrs r?locally_pushedzH2Stream.locally_pusheds2##11  * * z r>Nc|jjjd|||jj t j t|j}||_ |rD|jj t j|jjd|"|jjd||_ |xj|jzc_|jdk\sJ|gS)z Prepare some data frames. Optionally end the stream. .. warning:: Does not perform flow control checks. z)Send data on %r with end stream set to %srPADDEDr)rrrrr|rArQrrgdatarSrr pad_lengthrflow_controlled_length)rnrrrdfs r? send_datazH2Stream.send_datas   7z  (()?)?@ t~~ &     , ,\-I-I J HHLL &  ! HHLL "&BM ))R-F-FF)00A555t r>c|jjjd||jj t j t|j}|jjd|gS)z4 End a stream without sending data. z End stream %rr) rrrrr|rArSrrgrr)rnrs r?rzH2Stream.end_streams]   $7 (()E)EF t~~ &  \"t r>c|jjjd|||jj t j t|j}||_ |gS)z Advertise an RFC 7838 alternative service. The semantics of this are better documented in the ``H2Connection`` class. z*Advertise alternative service of %r for %r) rrrrr|rAr]r rgfield)rn field_valueasfs r?advertise_alternative_servicez&H2Stream.advertise_alternative_services[   8+t  (()N)NO$..) u r>c|jjjd|||jj t j |jj|t|j}||_ |gS)zS Increase the size of the flow control window for the remote side. z)Increase flow control window for %r by %d) rrrrr|rArRr window_openedr rgwindow_increment)rn incrementwufs r?increase_flow_control_windowz%H2Stream.increase_flow_control_windowsq   7 )  (()H)HI $$229=/(u r>c|jjjd|||jj t j }||d_|j|}|j||||d_ g|fS)z Receives a push promise frame sent on this stream, pushing a remote stream. This is called on the stream that has the PUSH_PROMISE sent on it. z/Receive Push Promise on %r for remote stream %dr) rrrrr|rArUpushed_stream_idr_process_received_headersr)rnrrheader_encodingrrs r?receive_push_promise_in_bandz%H2Stream.receive_push_promise_in_bands   = $ ##11  * * &8q "#??G :: )? q 6zr>c|jjjd||jj t j }t||_g|fS)z Mark this stream as one that was pushed by the remote peer. Must be called immediately after initialization. Sends no frames, simply updates the state machine. z%r pushed by remote peer) rrrrr|rArUr$r)rnpushed_headersrs r?remotely_pushedzH2Stream.remotely_pushedsV   !;TB##11  * * 1@6zr>ct|r|r tdtj}ntj}|j j |}|r;|j j tj}|d|d_||z }|j|t|dtr |s td|j|}|j||||d_g|fS)z9 Receive a set of headers (or trailers). z0Cannot set END_STREAM on informational responsesrz!Trailers must have END_STREAM set)r#rrAr\rTrr|rYr_initialize_content_lengthrqrrrr)rnrrr rvr es_eventsrs r?receive_headerszH2Stream.receive_headerss %W -#F"<c|jjjd||||jj t j }|jj||jt|||rG|jj t j}|d|d_ |j|||d_||d_g|fS)z$ Receive some data. zGReceive data on %r with end stream %s and flow control length set to %dr)rrrrr|rArWrwindow_consumed_track_content_lengthlenrYrextendrr)rnrrflow_control_lenrrs r? receive_datazH2Stream.receive_data&s    z+; ##11,2H2HI $$445EF ""3t9j9 **88,,I&/q\F1I " MM) $q +;q (6zr>c|jjjd|||jj t j }g}|r*||d_ t|j||_ ||fS||fS#t$r[t}|j|_ tj|_d|_|g}|j#|j}Y||fSwxYw)z3 Handle a WINDOW_UPDATE increment. z/Receive Window Update on %r for increment of %drF)rrrrr|rArXdeltar"rr!rrgrFLOW_CONTROL_ERRORrr reset_stream)rnrrrrs r?receive_window_updatezH2Stream.receive_window_update=s   = ) ##11  + +  'F1IO =4J5551v~vv~$ =$ "&..#-#@#@ %*"**5+;+;<v~ =s BAC'&C'c|jjjd||jj t j Jd)z 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 handle it. z Receive Continuation frame on %rzShould not be reachable)rrrrr|rArZrs r?receive_continuationzH2Stream.receive_continuationasI   !CTJ ((  * *  0//ur>cF|jjjd||jrggfS|jj t j}|r=t|dtsJ|j|d_|j|d_ g|fS)z An Alternative Service frame was received on the stream. This frame inherits the origin associated with this stream. z.Receive Alternative Service frame on stream %rr) rrroriginrr|rAr^rqrrrrrnframers r?receive_alt_svczH2Stream.receive_alt_svcms   c|jjjd|||jj t j t|j}||_ |gS)zP Close the stream locally. Reset the stream with an error code. z"Local reset %r with error code: %d) rrrrr|rArPr rgr)rnrrsfs r?rzH2Stream.reset_streams[   0$   (()E)EFT^^,#u r>c|jjjd||j|jj t j}|rt|j|d_g|fS)z7 Handle a stream being reset remotely. z#Remote reset %r with error code: %dr) rrrrrr|rArVrr"s r?rzH2Stream.stream_resetsk   149I9I ##11,2N2NO #78H8H#IF1I 6zr>c|jjjd|||jj |}|rt |j }||_|gSgS)z The user has informed us that they've processed some amount of data that was received on this stream. Pass that to the window manager and potentially return some WindowUpdate frames. z,Acknowledge received data with size %d on %r)rrrr process_bytesr rgr)rnacknowledged_sizerfs r?acknowledge_received_dataz"H2Stream.acknowledge_received_datasf   : t 00>>   !$..1A!*A 3J r>ct|dttf}t|dttt f}t|dt tf}t|jj|||S)z| Constructs a set of header validation flags for use when normalizing and validating header blocks. r) is_client is_traileris_response_headeris_push_promise) rqrrrrrrrr(rrh)rnrr/r0r1s r?rz$H2Stream._build_hdr_validation_flagss  1I '78 ( 1I -  % 1I,.@A %((//!1+   r>c|jjr t||}|jjr t||}|j|}t dt ||j Dcgc]}||||j z}}g}|d|_|j||ddD]/} t|j} | | _|j| 1|djjd|Scc}w)zH Helper method to build headers or push promise frames. rr N END_HEADERS) rr'r&encoderangerrrappendrrgrr) rnrr first_framerencoded_headersi header_blocksrblockcfs r?rzH2Stream._build_headers_framess ;; 1 10-G ;; 0 0/-G"..13')E)E  Aa < << =  (+  k""12&E"4>>2BBG MM" ' r ]+ # s8Dc|jjr t||}|jjr t||}|r t ||}t |S)z When headers have been received from the remote peer, run a processing pipeline on them to transform them into the appropriate form for attaching to an event. )rr*validate_inbound_headersr%_decode_headerslist)rnrheader_validation_flagsr s r?rz"H2Stream._process_received_headerssX ;; 0 0/0G ;; / /&w0GHG %g?GG}r>c|jdk(rd|_y|D]\}}|dk(s t|d|_yy#t$rt d|zwxYw)z Checks the headers for a content-length header and initializes the _expected_content_length field from it. It's not an error for no Content-Length header to be present. sHEADrNscontent-lengthrEz!Invalid content-length header: %s)rrintrrr)rnrnvs r?rz#H2Stream._initialize_content_lengthsr   ' ),-D ) DAq%%472JD1 "';a?s <Ac|xj|z c_|j}|j}|&||kr t|||r||k7r t||yyy)a Update the expected content length in response to data being received. Validates that the appropriate amount of data is sent. Always updates the received data, but only validates the length against the content-length header if one was sent. :param length: The length of the body chunk received. :param end_stream: If this is the last body chunk received. N)rrr )rnlengthractualexpecteds r?rzH2Stream._track_content_length+si ##v-#,,00  & ,Xv>>h&0,Xv>>1z r>c|jj|z}|jj|||j_y)aY We changed SETTINGS_INITIAL_WINDOW_SIZE, which means we need to update the target window size for flow control. For our flow control strategy, this means we need to do two things: we need to adjust the current window size, but we also need to set the target maximum window size to the new value. N)rmax_window_sizer)rnr new_max_sizes r?*_inbound_flow_control_change_from_settingsz3H2Stream._inbound_flow_control_change_from_settings@s<33CCeK  $$22597C$$4r>)F)FN)r)#r3r4r5rrorpropertyrrrrrrrrrrrrr r rrrrr$rrr,rrrrrrNr=r>r?rrs8 @@ 5 5>> 33 $/b0 6   0  D."H 06  ( 6)V0*?* Dr>rc#K|D]O}t|tsJ|\}}|j|}|j|}|j||Qyw)z Given an iterable of header two-tuples and an encoding, decodes those headers using that encoding while preserving the type of the header tuple. This ensures that the use of ``HeaderTuple`` is preserved. N)rqrdecode __class__)rencodingheadernamevalues r?r@r@Ms\ &+... e{{8$ X&tU++sAA)lrenumrrhpackrhyperframe.framerrrr r r r errorsrrrrrrrrrrrrrrrrr exceptionsrrr r! utilitiesr"r#r$r%r&r'r(r)r*windowsr+r-rArbr6rrr9r;r:rdr6rNrrTrrWrr<rOrr8rUrr7r^r_r`rrRrXrrPrrVrr]rrrrQrrSrYrrrr[rr\rrrrrrrrsrr@)_s0r?r_sm  5  #'4,T$As;'7898u89 $ K  -1 K ) )*.2 K * *+NF|001  * *K,<,<=F|001  . . 0@0@A F |--.  3 3[5G5GHF|556  4 4  & & (F|556  4 4  ' ' )F|<<= { F |223  * *K,I,IJ#F$|223  . .  * * ,'F.!:!:;  + +[-K-KL1F2!7!78  3 3[5G5GH5F6!@!@A {))*9F:!@!@A  , ,k.H.HI=F>!=!=>  / /1C1CDAFB!=!=>  * *K,>,>?EFF!F!FG  * *K,F,FGIFJ!F!FG {))*MFR  ,";";<  / /  ) ) +UFX  ,"8"89  3 3[5G5GH[F\  ,"A"AB {**+_F`  ,"A"AB  , ,k.I.IJcFd  ,">">?  / /1C1CDgFh  ,">">?  * *K,>,>?kFl  ,"G"GH  * *K,G,GHoFt|001  + +[-=-=>wFx|001  / /1A1AB{F||--. { F@|--.  + +[-=-=>CFD|334 {,,-GFH|334  0 0  ' ' )KFN|667 { QFR|667  , ,k.>.>?UFV|334  / /1C1CDYFZ|334  * *K,>,>?]F^|556  / /1A1ABaFb|556  / /1A1ABeFf|>>?  9 9;;K;KLiFj|>>?  9 9;;K;KLmFn|<<=  * *K,<,<=qFr|<<=  * *K,<,<=uFz##\%>%>?  + +[-K-KL}F~##\%>%>?  3 3[5G5GHAFB##\%;%;< {--.EFF##\%;%;<  3 3[5G5GHIFJ##\%A%AB  - -{/A/ABMFN##\%D%DE {--.QFR##\%D%DE  , ,k.L.LMUFV##\%A%AB  / /1C1CDYFZ##\%A%AB  * *K,>,>?]F^##\%C%CD  / /  * * ,aFd##\%C%CD  3 3[5G5GHgFh##\%L%LM  9 9  * * ,kFn##\%J%JK  * *K,J,JKqFr##\%J%JK  * *K,J,JKuFz""L$=$=>  / /  ) ) +}F@""L$:$:;  + +[-J-JKCFD""L$@$@A  * *K,>,>?GFH""L$C$CD {,,-KFL""L$C$CD  , ,k.K.KLOFP""L$@$@A  / /1C1CDSFT""L$@$@A  * *K,>,>?WFX""L$B$BC  / /  ) ) +[F^""L$K$KL  9 9  ) ) +aFd""L$I$IJ  * *K,I,IJgFh""L$I$IJ  * *K,I,IJkFp556 {!!"sFt>>? {!!"wFJ223  3 3[5G5GHMFN//0  3 3[5G5GHQF\889 {!!"556 {!!" 778  8 8+:L:LM223  3 3[5G5GH778  8 8+:L:LM556  3 3[5G5GH//0  3 3[5G5GH889  3 3[5G5GH556  3 3[5G5GHKF Rg Dg DT,A(:s% z