,hh SSKJrJrJrJrJrJrJrJrJ r J r SSK J r J r JrJrJrJrJr SSKJrJrJr SSKJrJr SSKJr SSKJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r& SSK'J(r(J)r)J*r* SS K+J,r,J-r- /S Qr."S S \*\*S 9r/"SS\*\*S 9r0Sr1S\ \\4S\24Sjr3S\4S\ \\4S\\5\ \S\\6444Sjr7"SS5r8g)) AnyCallablecastDictListOptionaloverloadTupleTypeUnion)ConnectionClosedData EndOfMessageEventInformationalResponseRequestResponse)get_comma_headerhas_expect_100_continueset_comma_header)READERS ReadersType) ReceiveBuffer) _SWITCH_CONNECT_SWITCH_UPGRADECLIENTConnectionStateDONEERRORMIGHT_SWITCH_PROTOCOL SEND_BODYSERVERSWITCHED_PROTOCOL)LocalProtocolErrorRemoteProtocolErrorSentinel)WRITERS WritersType) Connection NEED_DATAPAUSEDc\rSrSrSrg)r+3N__name__ __module__ __qualname____firstlineno____static_attributes__r/G/var/www/auris/envauris/lib/python3.13/site-packages/h11/_connection.pyr+r+3r6r+) metaclassc\rSrSrSrg)r,7r/Nr0r/r6r7r,r,7r8r6r,i@eventreturncb[URS5nSU;ag[USS5S:agg)N connectioncloseF http_version1.1T)rheadersgetattr)r< connections r7 _keep_aliverFTs4!%--?J:unf-6 r6request_methodr/c[U5[[4;de[U5[LaJURS;d'US:Xd!US:XaSURs=::aS:ag OgURS:de[ UR S5nU(a US/:Xdeg [ UR S 5nU(aS [ US 544$[U5[Lagg )N)i0HEADCONNECT,)content-length)rtransfer-encodingchunked)chunkedr/content-lengthrNr)http/1.0r/)typerr status_coderrCint)rGr<transfer_encodingscontent_lengthss r7 _body_framingrY]s ;7H- -- - E{h    +(*,8I8I1OC1O+2P+  C'''*%--9MN!j\111'u}}6GHO 3q'9#:"<== E{g'r6c \rSrSrSr\4S\\S\SS4Sjjr \ S\ \\\\44Sj5r \ S\\4S j5r \ S\\4S j5r\ S\4S j5rS%S jrS \\SS4SjrS\S\\\4SjrS \\S\SS4SjrS \\S\\S\\\4S\\S\44SjrS&S\ \\\\4S\\SS4Sjjr\ S\\\44Sj5r S\SS4Sjr!S\\\\"\\#44Sjr$S\\\\"\\#44Sjr%\&S\'SS4Sj5r(\&S\\)\*\+\,\-4S\4Sj5r(\&S\S\\4Sj5r(S\S\\4Sjr(S\S\\.\4S jr/S%S!jr0S"\+S\+4S#jr1S$r2g)'r*aAn object encapsulating the state of an HTTP connection. Args: our_role: If you're implementing a client, pass :data:`h11.CLIENT`. If you're implementing a server, pass :data:`h11.SERVER`. max_incomplete_event_size (int): The maximum number of bytes we're willing to buffer of an incomplete event. In practice this mostly sets a limit on the maximum size of the request/response line + headers. If this is exceeded, then :meth:`next_event` will raise :exc:`RemoteProtocolError`. our_rolemax_incomplete_event_sizer=NcX lU[[4;a[SU<35eXlU U[La [UlO [Ul[ 5UlURURS[5Ul URUR S[5Ul [5UlSUlSUlSUlSUlg)Nzexpected CLIENT or SERVER, not F)_max_incomplete_event_sizerr# ValueErrorr\ their_roler_cstate_get_io_objectr(_writerr_readerr_receive_buffer_receive_buffer_closedtheir_http_version_request_method"client_is_waiting_for_100_continue)selfr\r]s r7__init__Connection.__init__s +D' FF+ +>xlKL L  v $DO$DO&( **4==$H **4??D'J  -',#480438/r6c@[URR5$)zqA dictionary like:: {CLIENT: , SERVER: } See :ref:`state-machine` for details. )dictrbstatesrks r7rpConnection.statessDLL''((r6cHURRUR$)zZThe current state of whichever role we are playing. See :ref:`state-machine` for details. )rbrpr\rqs r7 our_stateConnection.our_states ||""4==11r6cHURRUR$)z^The current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )rbrprarqs r7 their_stateConnection.their_states ||""4??33r6cLUR[L=(a UR$N)rarrjrqs r7!they_are_waiting_for_100_continue,Connection.they_are_waiting_for_100_continues&(TT-T-TTr6c[URR5nURR5 SUlUR (aeUR U5 g)aIAttempt to reset our connection state for a new request/response cycle. If both client and server are in :data:`DONE` state, then resets them both to :data:`IDLE` state in preparation for a new request/response cycle on this same connection. Otherwise, raises a :exc:`LocalProtocolError`. See :ref:`keepalive-and-pipelining`. N)rorbrpstart_next_cyclerirj_respond_to_state_changes)rk old_statess r7r~Connection.start_next_cyclesO$,,--.  %%'#:::: &&z2r6rolec[URR5nURRU5 UR U5 grz)rorbrp process_errorr)rkrrs r7_process_errorConnection._process_errors6$,,--.  ""4( &&z2r6r<c[U5[LaURS:Xa[$[U5[La>[ UR R;a SURs=::a S:a [ $ gg)NerLrM)rTrrUrrrrbpending_switch_proposalsrkr<s r7_server_switch_eventConnection._server_switch_eventsc ;/ /E4E4E4L" " ;( "4<<#H#HH5,,2s2&&3r6c[URR5nU[La{[ U5[ LaiUR S:XaURR[5 [URS5(aURR[5 SnU[LaURU5nURRU[ U5U5 [ U5[ LaUR UlXR LaQ[ U5[ ["[$4;a3['[([ ["[$4U5nUR*Ul[ U5[ ["4;aE[/['[([ ["4U55(dURR15 [ U5[ La[3U5(aSUl[ U5[$["4;aSUlU[La [ U5[6[84;aSUlUR;X25 g)NrKsupgradeTF)rorbrprrTrmethodprocess_client_switch_proposalrrrCrr#r process_eventrirarrrr rArhrFprocess_keep_alive_disabledrrjrrr)rkrr<rserver_switch_events r7_process_eventConnection._process_events$,,--. 6>d5kW4||z) ;;OL z:: ;;OL" 6>"&";";E"B  ""4e6IJ ;' !#(<d5kdL-AA6;D 3 &&z9r6io_dict.c URRUnU[LaP[[ [ UR 5[ [[[4U55upVU[U"U6$URX45$rz) rbrpr"rYrbytesrir rrget)rkrr<rstate framing_typeargss r7rcConnection._get_io_object@s} ##D) I "/UD0014gx>O8PRW3X" L9%l3T: :;;}- -r6rcURXR:wa&URURU[5UlUR XR :wa'URUR U[5Ulggrz) rtr\rcr(rdrwrarre)rkrr<s r7r$Connection._respond_to_state_changesVse >>Z 6 6..t}}eWMDL   z//: :..twODL ;r6cD[UR5UR4$)a:Data that has been received, but not yet processed, represented as a tuple with two elements, where the first is a byte-string containing the unprocessed data itself, and the second is a bool that is True if the receive connection was closed. See :ref:`switching-protocols` for discussion of why you'd want this. )rrfrgrqs r7 trailing_dataConnection.trailing_dataas d**+T-H-HIIr6datacU(a2UR(a [S5eU=RU- slgSUlg)aAdd data to our internal receive buffer. This does not actually do any processing on the data, just stores it. To trigger processing, you have to call :meth:`next_event`. Args: data (:term:`bytes-like object`): The new data that was just received. Special case: If *data* is an empty byte-string like ``b""``, then this indicates that the remote side has closed the connection (end of file). Normally this is convenient, because standard Python APIs like :meth:`file.read` or :meth:`socket.recv` use ``b""`` to indicate end-of-file, while other failures to read are indicated using other mechanisms like raising :exc:`TimeoutError`. When using such an API you can just blindly pass through whatever you get from ``read`` to :meth:`receive_data`, and everything will work. But, if you have an API where reading an empty string is a valid non-EOF condition, then you need to be aware of this and make sure to check for such strings and avoid passing them to :meth:`receive_data`. Returns: Nothing, but after calling this you should call :meth:`next_event` to parse the newly received data. Raises: RuntimeError: Raised if you pass an empty *data*, indicating EOF, and then pass a non-empty *data*, indicating more data that somehow arrived after the EOF. (Calling ``receive_data(b"")`` multiple times is fine, and equivalent to calling it once.) z(received close, then received more data?TN)rg RuntimeErrorrf)rkrs r7 receive_dataConnection.receive_datals6N **"#MNN  D ( *.D 'r6cURnU[LaUR(a[$U[Ld U[ La[$UR ceUR UR5nUcbUR(dQUR(a@[UR S5(aUR R5nO [5nUc[nU$)Nread_eof) rwrrfr,r!r$rerghasattrrrr+)rkrr<s r7_extract_next_receive_event&Connection._extract_next_receive_events   D=T11M ) )U6G-GM||''' T112 =''D,G,G 4<<44 LL113E,.E =E r6c,UR[La [S5eUR5nU[[ 4;a*UR UR[[U55 U[LaI[UR5UR:a [SSS9eUR(a [S5eU$![aKnURUR5 [!U["5(aUR%5 SnAgeSnAff=f)anParse the next event out of our receive buffer, update our internal state, and return it. This is a mutating operation -- think of it like calling :func:`next` on an iterator. Returns: : One of three things: 1) An event object -- see :ref:`events`. 2) The special constant :data:`NEED_DATA`, which indicates that you need to read more data from your socket and pass it to :meth:`receive_data` before this method will be able to return any more events. 3) The special constant :data:`PAUSED`, which indicates that we are not in a state where we can process incoming data (usually because the peer has finished their part of the current request/response cycle, and you have not yet called :meth:`start_next_cycle`). See :ref:`flow-control` for details. Raises: RemoteProtocolError: The peer has misbehaved. You should close the connection (possibly after sending some kind of 4xx response). Once this method returns :class:`ConnectionClosed` once, then all subsequent calls will also return :class:`ConnectionClosed`. If this method raises any exception besides :exc:`RemoteProtocolError` then that's a bug -- if it happens please file a bug report! If this method raises any exception then it also sets :attr:`Connection.their_state` to :data:`ERROR` -- see :ref:`error-handling` for discussion. z+Can't receive data when peer state is ERRORzReceive buffer too longi)error_status_hintz#peer unexpectedly closed connectionN)rwr r&rr+r,rrarrlenrfr_rg BaseExceptionr isinstancer%!_reraise_as_remote_protocol_error)rkr<excs r7 next_eventConnection.next_eventsP   u $%&ST T 446EY//##DOOT%5GH !t++,t/N/NN.1S....STTL     0#1225577  sBB>> DAD DDcgrzr/rs r7sendConnection.send r6cgrzr/rs r7rrs r6cgrzr/rs r7rrrr6cNURU5nUcgSRU5$)aCConvert a high-level event into bytes that can be sent to the peer, while updating our internal state machine. Args: event: The :ref:`event ` to send. Returns: If ``type(event) is ConnectionClosed``, then returns ``None``. Otherwise, returns a :term:`bytes-like object`. Raises: LocalProtocolError: Sending this event at this time would violate our understanding of the HTTP/1.1 protocol. If this method raises any exception then it also sets :attr:`Connection.our_state` to :data:`ERROR` -- see :ref:`error-handling` for discussion. Nr6)send_with_data_passthroughjoin)rkr< data_lists r7rrs,*33E:  88I& &r6ctUR[La [S5e[U5[LaUR U5nUR nURURU5 [U5[LagUce/nU"XR5 U$! URUR5 e=f)a@Identical to :meth:`send`, except that in situations where :meth:`send` returns a single :term:`bytes-like object`, this instead returns a list of them -- and when sending a :class:`Data` event, this list is guaranteed to contain the exact object you passed in as :attr:`Data.data`. See :ref:`sendfile` for discussion. z'Can't send data when our state is ERRORN) rtr r%rTr&_clean_up_response_headers_for_sendingrdrr\rappendr)rkr<writerrs r7r%Connection.send_with_data_passthrough s >>U "$%NO O E{h&CCEJ \\F    u 5E{..))))+ u../       . sAB>BB7c:URUR5 g)zNotify the state machine that we failed to send the data it gave us. This causes :attr:`Connection.our_state` to immediately become :data:`ERROR` -- see :ref:`error-handling` for discussion. N)rr\rqs r7 send_failedConnection.send_failedAs DMM*r6responsec[U5[LdeURnSn[[UR 5nUS:XaSn[ XA5upVUS;aX[US/5nURbURS:a [US/5nUR S:waSnO[USS /5nURR(aU(aM[[US 55nURS 5 URS 5 [US [U55n[UUR UR"UR$S 9$)NFrJsGET)rQrSrRrBrOTrPr?s keep-aliver@)rCrUrAreason)rTrrCrrrirYrrhrb keep_alivesetrdiscardaddsortedrUrAr)rkrrC need_closemethod_for_choosing_headersr_rEs r7r1Connection._clean_up_response_headers_for_sendingZs6H~)))"" '+5$2F2F&G# &' 1*0 ''(CN 2 2'w0A2FG&&.$2I2IF2R +74H"M ''72!%J*74H:,W||&&*-g}EFJ   } - NN8 $&w vj?QRG ,,!..??   r6) rbr_rerfrgrirdrjr\rhra)r=Nrz)3r1r2r3r4__doc__!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr r'rVrlpropertyrrprtrwboolr{r~rrrrrr rr)rrrcrr rrrr+r,rrr rrrrrrrrrrrr5r/r6r7r*r*s $*K%8x.%8$'%8  %8N)T(^T(^;<))24>22 4T(^44 U4UU3(34>3d3 % HT(^4L .:4>.:%.:D.:`.8n..{K/0 . (38$ % .2"& Phh78 P P  PJuUD[1JJ,/,/4,/\ ud9otF|3 48?E%i$v,"FG?B * t   7$98T<WX    % HUO  '%'HUO'6(4;:OB+29 x9 H9 r6r*N)9typingrrrrrrr r r r _eventsrrrrrrr_headersrrr_readersrr_receivebufferr_staterrrrrr r!r"r#r$_utilr%r&r'_writersr(r)__all__r+r,rrrFrstrrVrYr*r/r6r7rs   RQ*)    + 0 H  X %.!uWh./D0 0 "'(9":0  3eBis+, ,-0 t| | r6