WhaddlTddlmZmZmZddlmZddlmZddl Tddl m Z m Z m Z ddl mZmZmZddlmZgdZed Zed Zd Zd Zd ZGddZdS))*)get_comma_headerhas_expect_100_continueset_comma_header)READERS) ReceiveBuffer)_SWITCH_CONNECT_SWITCH_UPGRADEConnectionState)LocalProtocolError make_sentinelRemoteProtocolError)WRITERS) Connection NEED_DATAPAUSEDrri@cjt|jd}d|vrdSt|dddkrdSdS)N connectioncloseF http_version1.1T)rheadersgetattr)event connections U/var/www/html/movieo_spanner_bot/venv/lib/python3.11/site-packages/h11/_connection.py _keep_aliver/sD!%-??J:uunf--66u 4ct|ttfvsJt|tur9|jdvs!|dks|dkrd|jcxkrdkrnndS|jdksJt |jd}|r |dgksJd St |jd }|rd t |d ffSt|turdSd S)N)i0HEADCONNECT,)content-length)transfer-encodingschunked)chunkedcontent-lengthr%r&)http/1.0r))typeRequestResponse status_coderrint)request_methodrtransfer_encodingscontent_lengthss r _body_framingr48s" ;;7H- - - - - E{{h   + +((*,,8I1O1O1O1OC1O1O1O1O1O++ C''''*%-9MNN!j\1111'u}6GHHO> 3q'9#:#:"<== E{{g''rceZdZdZefdZedZedZedZ edZ dZ dZ d Z d Zd Zdd ZedZdZdZdZdZdZdZdZd S)raBAn 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`. c||_|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_sizeCLIENTSERVER ValueErrorformatour_role their_roler _cstate_get_io_objectr_writerr_readerr_receive_buffer_receive_buffer_closedtheir_http_version_request_method"client_is_waiting_for_100_continue)selfr<max_incomplete_event_sizes r__init__zConnection.__init__s+D' FF+ + +BII(SSTT T  v  $DOO$DO&(( **4=$HH **4?D'JJ  -',##'#38///rc4t|jjS)zA dictionary like:: {CLIENT: , SERVER: } See :ref:`state-machine` for details. )dictr>statesrGs rrLzConnection.statessDL'(((rc0|jj|jS)zjThe current state of whichever role we are playing. See :ref:`state-machine` for details. )r>rLr<rMs r our_statezConnection.our_states |"4=11rc0|jj|jS)znThe current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )r>rLr=rMs r their_statezConnection.their_states |"4?33rc,|jtuo|jSN)r=r8rFrMs r!they_are_waiting_for_100_continuez,Connection.they_are_waiting_for_100_continues&(TT-TTrct|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)rKr>rLstart_next_cyclerErF_respond_to_state_changes)rG old_statess rrVzConnection.start_next_cycles]$,-..  %%'''#:::: &&z22222rct|jj}|j|||dSrS)rKr>rL process_errorrW)rGrolerXs r_process_errorzConnection._process_errorsD$,-..  ""4((( &&z22222rct|tur|jdkrtSt|tur/t |jjvrd|jcxkrdkr nnt SdS)Ner#r$)r,InformationalResponser/r r.r r>pending_switch_proposals)rGrs r_server_switch_eventzConnection._server_switch_eventsx ;;/ / /E4E4L4L" " ;;( " "4<#HHH5,2222s22222&&trc(t|jj}|turtt |t ur^|jdkr|jtt|j dr|jtd}|tur| |}|j|t ||t |t ur |j|_||jur/t |t t"t$fvr |j|_t |t t"fvr(t+|s|jt |t urt/|rd|_t |t$t"fvrd|_|tur$t |t2t4fvrd|_|||dS)Nr"supgradeTF)rKr>rLr8r,r-methodprocess_client_switch_proposalr rrr r9ra process_eventrEr=r.r_rrDrprocess_keep_alive_disabledrrFData EndOfMessagerW)rGr[rrXserver_switch_events r_process_eventzConnection._process_events$,-.. 6>>d5kkW44|z)) ;;OLLL z:: M ;;OLLL" 6>>"&";";E"B"B  ""4e6IJJJ ;;' ! !#(>d5kkdL-AAA6;D 3 &&z599999rc|jj|}|tur.t|j|\}}|t||S|||fSrS)r>rL SEND_BODYr4rEget)rGr[rio_dictstate framing_typeargss rr?zConnection._get_io_objectsd #D) I  "/t/CU!K!K L$379%l3T: :;;e}-- -rNc|j||jkr&||j|t|_|j||jkr(||j|t|_dSdSrS) rOr<r?rr@rQr=rrA)rGrXrs rrWz$Connection._respond_to_state_changes$sm >Z 6 6 6..t}eWMMDL  z$/: : :..twOODLLL ; :rc8t|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. )bytesrBrCrMs r trailing_datazConnection.trailing_data+sd*++T-HIIrch|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)rC RuntimeErrorrB)rGdatas r receive_datazConnection.receive_data6sPN  /* O"#MNNN  D ( *.D ' ' 'rcf|j}|tur|jrtS|tus |t urtS|jJ||j}|K|jsD|jr=t|jdr|j }nt}|t}|S)Nread_eof) rQDONErBrMIGHT_SWITCH_PROTOCOLSWITCHED_PROTOCOLrArChasattrr{ConnectionClosedr)rGrors r_extract_next_receive_eventz&Connection._extract_next_receive_eventds  D==T1=M ) ) )U6G-G-GM|''' T122 =' /D,G / 4<44/ L1133EE,..E =E rc|jturtd |}|tt fvr||j||turDt|j |j krtdd|j rtd|S#t$rP}| |jt|tr|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)rQERRORrrrrrjr=lenrBr7rC BaseExceptionr\ isinstancer !_reraise_as_remote_protocol_error)rGrexcs r next_eventzConnection.next_event~s:P  u $ $%&STT T 4466EY///##DOU;;; !!t+,,t/NNN.1S.U..STTTL       0 0 0#122 557777877777 sB B-- D7ADDc^||}|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. Nr)send_with_data_passthroughjoin)rGr data_lists rsendzConnection.sends4*33E::  488I&& &rcz|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) rOrr r,r.&_clean_up_response_headers_for_sendingr@rjr<rappendr\)rGrwriterrs rrz%Connection.send_with_data_passthroughs >U " "$%NOO O E{{h&&;;EBBB \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)r\r<rMs r send_failedzConnection.send_faileds  DM*****rc0t|tusJ|j}d}|j}|dkrd}t ||\}}|dvrTt |dg}|j |jdkrt |dg}|jdkrd}nt |dd g}|jjr|rett|d }| d | d t |d t|}||_dS) NFr!sGET)r(r+r*rr'Tr(rs keep-aliver)r,r.rrEr4rrDr> keep_alivesetrdiscardaddsorted)rGresponser need_closemethod_for_choosing_headersrp_rs rrz1Connection._clean_up_response_headers_for_sendingsEH~~))))" '+&:# &' 1 1*0 ''(CXNN a 2 2 2'w0A2FFG&.$2IF2R2R +74H"MM '722!%J*74H9+VV|& S* S-g}EEFFJ   } - - - NN8 $ $ $&w vj?Q?QRRG"rrS)__name__ __module__ __qualname____doc__!DEFAULT_MAX_INCOMPLETE_EVENT_SIZErIpropertyrLrOrQrTrVr\rarjr?rWruryrrrrrrr)rrrrps   3T"8"8"8"8H))X)22X2 44X4 UUXU333(333   -:-:-:^ . . .PPPPJJXJ,/,/,/\4???B'''6B+++44#4#4#4#4#rrN)_events_headersrrr_readersr_receivebufferr_stater r r _utilr r r_writersr__all__rrrrr4rr)rrrsSQQQQQQQQQQ))))))EEEEEEEEEE  0 / / M+ & & x %.!. . . pY#Y#Y#Y#Y#Y#Y#Y#Y#Y#r