a hh@shddlmZmZmZmZmZmZmZmZm Z m Z ddl m Z m Z mZmZmZmZmZddlmZmZmZddlmZmZddlmZddlmZmZmZm Z m!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 d e*e*d Z/Gddde*e*d Z0dZ1e eefe2dddZ3e4e eefee5e edee6ffdddZ7GdddZ8dS)) 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@s eZdZdS)r*N__name__ __module__ __qualname__r0r0K/var/www/html/assistant/venv/lib/python3.9/site-packages/h11/_connection.pyr*3sr*) metaclassc@s eZdZdS)r+Nr,r0r0r0r1r+7sr+i@eventreturncCs0t|jd}d|vrdSt|dddkr,dSdS)N connectioncloseF http_version1.1T)rheadersgetattr)r4 connectionr0r0r1 _keep_aliveTs  r=r0)request_methodr4r5cCst|ttfvsJt|turf|jdvsT|dksT|dkrXd|jkrPdkrXnndS|jdksfJt|jd}|r|dgksJd St|jd }|rd t|d ffSt|turdSd SdS)N)i0HEADCONNECT,)content-length)rtransfer-encodingchunked)chunkedr0content-lengthrDr)http/1.0r0)typerr status_coderr:int)r>r4Ztransfer_encodingsZcontent_lengthsr0r0r1 _body_framing]s0     rMc@s4eZdZdZefeeeddddZe e eeeefdddZ e eedd d Z e eedd d Z e edd dZddddZeeddddZeeeedddZeeeddddZeeeeeeefeedefdddZd6e eeeefeedddd Ze eeefdd!d"Zedd#d$d%Z eeee!ee"fdd&d'Z#eeee!ee"fdd(d)Z$e%e&ddd*d+Z'e%ee(e)e*e+e,fedd,d+Z'e%eeedd-d+Z'eeedd.d+Z'eee-edd/d0Z.ddd1d2Z/e*e*d3d4d5Z0dS)7r)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`. N)our_rolemax_incomplete_event_sizer5cCs||_|ttfvr td|||_||tur:t|_nt|_t|_||jdt |_ ||jdt |_ t |_d|_d|_d|_d|_dS)Nzexpected CLIENT or SERVER, not F)_max_incomplete_event_sizerr" ValueErrorrN their_roler_cstate_get_io_objectr'_writerr_readerr_receive_buffer_receive_buffer_closedtheir_http_version_request_method"client_is_waiting_for_100_continue)selfrNrOr0r0r1__init__s  zConnection.__init__)r5cCs t|jjS)zA dictionary like:: {CLIENT: , SERVER: } See :ref:`state-machine` for details. )dictrSstatesr\r0r0r1r_s zConnection.statescCs|jj|jS)zjThe current state of whichever role we are playing. See :ref:`state-machine` for details. )rSr_rNr`r0r0r1 our_stateszConnection.our_statecCs|jj|jS)znThe current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )rSr_rRr`r0r0r1 their_stateszConnection.their_statecCs|jtuo|jSN)rRrr[r`r0r0r1!they_are_waiting_for_100_continuesz,Connection.they_are_waiting_for_100_continuecCs4t|jj}|jd|_|jr&J||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)r^rSr_start_next_cyclerZr[_respond_to_state_changes)r\ old_statesr0r0r1res   zConnection.start_next_cycle)roler5cCs&t|jj}|j|||dSrc)r^rSr_Z process_errorrf)r\rhrgr0r0r1_process_errors  zConnection._process_errorr3cCsTt|tur|jdkrtSt|turPt|jjvrPd|jkrHdkrPnntSdS)NerBrC)rJrrKrrrrSZpending_switch_proposalsr\r4r0r0r1_server_switch_events   zConnection._server_switch_event)rhr4r5cCs\t|jj}|turNt|turN|jdkr6|jtt |j drN|jt d}|t urd| |}|j|t||t|tur|j|_||jurt|tttfvrtttttf|}|j|_t|ttfvrtttttf|s|jt|turt|rd|_t|ttfvr*d|_|turLt|ttfvrLd|_|||dS)NrAsupgradeTF)r^rSr_rrJrmethodZprocess_client_switch_proposalrrr:rr"rlZ process_eventrZrRrrrr r8rYr=Zprocess_keep_alive_disabledrr[rrrf)r\rhr4rgZserver_switch_eventr0r0r1_process_events<        zConnection._process_event.)rhr4io_dictr5cCsZ|jj|}|turHttt|jtttt f|\}}|t||S| ||fSdSrc) rSr_r!rMrbytesrZr rrget)r\rhr4rostate framing_typeargsr0r0r1rT@s zConnection._get_io_object)rgr4r5cCsH|j||jkr"||j|t|_|j||jkrD||j|t|_dSrc) rarNrTr'rUrbrRrrV)r\rgr4r0r0r1rfVsz$Connection._respond_to_state_changescCst|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. )rprWrXr`r0r0r1 trailing_dataas zConnection.trailing_data)datar5cCs,|r"|jrtd|j|7_nd|_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)rX RuntimeErrorrW)r\rvr0r0r1 receive_datals 'zConnection.receive_datacCs|j}|tur|jrtS|tus(|tur,tS|jdus:J||j}|durx|jsx|jrxt|jdrr|j }nt }|durt }|S)Nread_eof) rbrrWr+r r#rVrXhasattrryr r*)r\rrr4r0r0r1_extract_next_receive_events    z&Connection._extract_next_receive_eventc Cs|jturtdz`|}|ttfvr<||jtt ||turnt |j |j kr`tddd|j rntd|WSty}z.||jt|tr|nWYd}~n d}~00dS)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)Zerror_status_hintz#peer unexpectedly closed connectionN)rbrr%r{r*r+rnrRrrlenrWrPrX BaseExceptionri isinstancer$Z!_reraise_as_remote_protocol_error)r\r4excr0r0r1 next_events&(     zConnection.next_eventcCsdSrcr0rkr0r0r1sendszConnection.sendcCsdSrcr0rkr0r0r1rscCsdSrcr0rkr0r0r1rscCs$||}|durdSd|SdS)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. N)send_with_data_passthroughjoin)r\r4 data_listr0r0r1rs cCs|jturtdzbt|tur*||}|j}||j|t|t urPWdS|dus\Jg}|||j |WSWn| |jYn0dS)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) rarr$rJr&_clean_up_response_headers_for_sendingrUrnrNr appendri)r\r4writerrr0r0r1r s         z%Connection.send_with_data_passthroughcCs||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)rirNr`r0r0r1 send_failedAszConnection.send_failed)responser5cCst|tusJ|j}d}tt|j}|dkr2d}t||\}}|dvrt|dg}|jdush|jdkrt|dg}|jdkrd}nt|dd g}|j j r|rt t |d }| d |d t|d t|}t||j|j|jd S)NFr@sGET)rGrIrHr9rETrFr6s keep-aliver7)r:rKr8reason)rJrr:rrprZrMrrYrS keep_alivesetrdiscardaddsortedrKr8r)r\rr:Z need_closeZmethod_for_choosing_headersrs_r<r0r0r1rZs2       z1Connection._clean_up_response_headers_for_sending)N)1r-r.r/__doc__!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr r&rLr]propertyrr_rarbboolrdrerirrrlrnr rr(rrrTrfr rprurxr*r+r{rrr rrrrrrrrrrr0r0r0r1r)s` '  2    0  A!r)N)9typingrrrrrrrr r r Z_eventsr rrrrrr_headersrrr_readersrrZ_receivebufferr_staterrrrrrr r!r"r#Z_utilr$r%r&_writersr'r(__all__r*r+rrr=rpstrrLrMr)r0r0r0r1s 0 $  0   :