gg ddlmZmZmZmZmZmZmZmZm Z ddl m Z m Z m Z mZmZmZmZddlmZmZmZddlmZmZddlmZddlmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%ddl&m'Z'm(Z(m)Z)dd l*m+Z+m,Z,gd Z-Gd d e)e) Z.Gdde)e) Z/dZ0de eefde1fdZ2de3de eefdee4e edee5fffdZ6GddZ7dS)) AnyCallablecastDictListOptionalTupleTypeUnion)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_DATAPAUSEDceZdZdS)r*N__name__ __module__ __qualname__M/var/www/html/mpstechhub/venv/lib/python3.11/site-packages/h11/_connection.pyr*r*(Dr2r*) metaclassceZdZdS)r+Nr-r1r2r3r+r+,r4r2r+i@eventreturncjt|jd}d|vrdSt|dddkrdSdS)N connectioncloseF http_version1.1T)rheadersgetattr)r7 connections r3 _keep_aliverAHsD!%-??J:uunf--66u 4r2request_methodr1ct|ttfvsJt|tur9|jdvs!|dks|dkrd|jcxkrdkrnndS|jdksJt |jd}|r |dgksJd St |jd }|rd t |d ffSt|turdSd S)N)i0HEADCONNECT,)content-length)rtransfer-encodingchunked)chunkedr1content-lengthrIr)http/1.0r1)typerr status_coderr>int)rBr7transfer_encodingscontent_lengthss r3 _body_framingrTQs" ;;7H- - - - - E{{h   + +((*,,8I1O1O1O1OC1O1O1O1O1O++ C''''*%-9MNN!j\1111'u}6GHHO> 3q'9#:#:"<== E{{g''r2c eZdZdZefdeededdfdZe de eeeeffdZ e deefdZ e deefd Z e defd Zd d Zd eeddfd ZdedeeefdZd eededdfdZd eedeedeeefdeedeffdZ d!de eeeefdeeddfdZe deeeffdZdeddfdZ deeee!ee"ffdZ#deeee!ee"ffdZ$dedeefdZ%dedee&efdZ'd dZ(de)de)fdZ*dS)"r)aBAn 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_sizer8Nc||_|ttfvr"td|||_||tur t|_n t|_t|_| |jdt|_ | |jdt|_ t|_d|_d|_d|_d|_dS)Nz#expected CLIENT or SERVER, not {!r}F)_max_incomplete_event_sizerr" ValueErrorformatrV their_roler_cstate_get_io_objectr'_writerr_readerr_receive_buffer_receive_buffer_closedtheir_http_version_request_method"client_is_waiting_for_100_continue)selfrVrWs r3__init__zConnection.__init__s +D' FF+ + +BII(SSTT T   ' v  $DOO$DO&(( **4=$HH **4?D'JJ  -',#480438///r2c4t|jjS)zA dictionary like:: {CLIENT: , SERVER: } See :ref:`state-machine` for details. )dictr]statesrfs r3rjzConnection.statessDL'(((r2c0|jj|jS)zjThe current state of whichever role we are playing. See :ref:`state-machine` for details. )r]rjrVrks r3 our_statezConnection.our_states |"4=11r2c0|jj|jS)znThe current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )r]rjr\rks r3 their_statezConnection.their_states |"4?33r2c,|jtuo|jSN)r\rrerks r3!they_are_waiting_for_100_continuez,Connection.they_are_waiting_for_100_continues&(TT-TTr2ct|jj}|jd|_|jrJ||dS)aAttempt 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)rir]rjstart_next_cyclerdre_respond_to_state_changes)rf old_statess r3rtzConnection.start_next_cycles]$,-..  %%'''#:::: &&z22222r2rolect|jj}|j|||dSrq)rir]rj process_errorru)rfrwrvs r3_process_errorzConnection._process_errorsD$,-..  ""4((( &&z22222r2r7ct|tur|jdkrtSt|tur/t |jjvrd|jcxkrdkr nnt SdS)NerGrH)rOrrPrrrr]pending_switch_proposals)rfr7s r3_server_switch_eventzConnection._server_switch_eventsx ;;/ / /E4E4L4L" " ;;( " "4<#HHH5,2222s22222&&tr2ct|jj}|turtt |t ur^|jdkr|jtt|j dr|jtd}|tur| |}|j|t ||t |t ur |j|_||jur\t |t t"t$fvr9t't(t t"t$f|}|j|_t |t t"fvrMt/t't(t t"f|s|jt |t urt3|rd|_t |t$t"fvrd|_|tur$t |t6t8fvrd|_|||dS)NrFsupgradeTF)rir]rjrrOrmethodprocess_client_switch_proposalrrr>rr"r~ process_eventrdr\rrrr r<rcrAprocess_keep_alive_disabledrrerrru)rfrwr7rvserver_switch_events r3_process_eventzConnection._process_events$,-.. 6>>d5kkW44|z)) ;;OLLL z:: M ;;OLLL" 6>>"&";";E"B"B  ""4e6IJJJ ;;' ! !#(>d5kkdL-AAA6;D 3 &&z599999r2io_dict.c2|jj|}|turftt t |jt tttf|\}}|t||S| ||fSrq) r]rjr!rTrbytesrdr rrget)rfrwr7rstate framing_typeargss r3r^zConnection._get_io_object4s #D) I  "/UD0114gx>O8PRW3X3X"" L$479%l3T: :;;e}-- -r2rvc|j||jkr&||j|t|_|j||jkr(||j|t|_dSdSrq) rmrVr^r'r_ror\rr`)rfrvr7s r3ruz$Connection._respond_to_state_changesJso >Z 6 6 6..t}eWMMDL  z$/: : :..twOODLLL ; :r2c8t|j|jfS)abData 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. )rrarbrks r3 trailing_datazConnection.trailing_dataUsd*++T-HIIr2datach|r(|jrtd|xj|z c_dSd|_dS)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)rb RuntimeErrorra)rfrs r3 receive_datazConnection.receive_data`sPN  /* O"#MNNN  D ( *.D ' ' 'r2cf|j}|tur|jrtS|tus |t urtS|jJ||j}|K|jsD|jr=t|jdr|j }nt}|t}|S)Nread_eof) rorrar+r r#r`rbhasattrrr r*)rfrr7s r3_extract_next_receive_eventz&Connection._extract_next_receive_events  D==T1=M ) ) )U6G-G-GM|''' T122 =' /D,G / 4<44/ L1133EE,..E =E r2c:|jturtd |}|tt fvr.||jtt||turDt|j |j krtdd|j rtd|S#t$rP}||jt!|t"r|nYd}~dSd}~wwxYw)aFParse 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)rorr%rr*r+rr\rrlenrarYrb BaseExceptionrz isinstancer$!_reraise_as_remote_protocol_error)rfr7excs r3 next_eventzConnection.next_eventsDP  u $ $%&STT T 4466EY///##DOT%5G5GHHH !!t+,,t/NNN.1S.U..STTTL       0 0 0#122 557777877777 sB C D ADDc^||}|dSd|S)aConvert 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. Nr2)send_with_data_passthroughjoin)rfr7 data_lists r3sendzConnection.sends4*33E::  488I&& &r2cz|jturtd t|tur||}|j}||j|t|turdS|Jg}|||j |S#| |jxYw)ahIdentical 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) rmrr$rOr&_clean_up_response_headers_for_sendingr_rrVr appendrz)rfr7writerrs r3rz%Connection.send_with_data_passthroughs >U " "$%NOO O E{{h&&CCEJJ \F    u 5 5 5E{{...t))))+ ui.///       . . . sA#BBB:c:||jdS)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)rzrVrks r3 send_failedzConnection.send_failed's  DM*****r2responsect|tusJ|j}d}tt|j}|dkrd}t ||\}}|dvrTt|dg}|j |jdkrt|dg}|jdkrd}nt|dd g}|j j r|rett|d }| d |d t|d t|}t||j|j|j S)NFrEsGET)rLrNrMr=rJTrKr:s keep-aliver;)r>rPr<reason)rOrr>rrrdrTrrcr] keep_alivesetrdiscardaddsortedrPr<r)rfrr> need_closemethod_for_choosing_headersr_r@s r3rz1Connection._clean_up_response_headers_for_sending@slH~~))))" '+5$2F&G&G# &' 1 1*0 ''(CXNN a 2 2 2'w0A2FFG&.$2IF2R2R +74H"MM '722!%J*74H:,WW|& S* S-g}EEFFJ   } - - - NN8 $ $ $&w vj?Q?QRRG ,!.?     r2)r8Nrq)+r.r/r0__doc__!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr r&rQrgpropertyrrjrmroboolrrrtrzrrr~rr rr(rrr^rur rrrr*r+rrrrrrrrr1r2r3r)r)s  $*K%8%8x.%8$'%8  %8%8%8%8N)T(^T(^;<)))X)24>222X2 4T(^444X4 U4UUUXU3333(34>3d3333 % HT(^4L    .:4>.:%.:D.:.:.:.:`.8n..{K/0 . (38$ % ....2"& P Phh78 P P  P P P PJuUD[1JJJXJ,/,/4,/,/,/,/\ ud9otF|3 48?E%i$v,"FG????B'%'HUO''''6(4;:OB++++29 x9 H9 9 9 9 9 9 r2r)N)8typingrrrrrrr r r _eventsr rrrrrr_headersrrr_readersrr_receivebufferr_staterrrrrrr r!r"r#_utilr$r%r&_writersr'r(__all__r*r+rrrArstrrQrTr)r1r2r3rsQPPPPPPPPPPPPPPPPPPPPPRQQQQQQQQQ********))))))                         +******* 0 / /     H         X    %.!uWh./D0 0 "'(9":0  3eBis+, ,-0 0 0 0 tn n n n n n n n n n r2