o [hh @snddlmZmZmZmZmZmZmZmZm 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 Z0dZ1de eefde2fddZ3de4de eefdee5e edee6fffddZ7GdddZ8dS)) 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@ eZdZdS)r*N__name__ __module__ __qualname__r1r1v/home/ubuntu/experiments/live_experiments/Pythonexperiments/Otree/venv/lib/python3.10/site-packages/h11/_connection.pyr*3r*) metaclassc@r,)r+Nr-r1r1r1r2r+7r3r+i@eventreturncCs0t|jd}d|vr dSt|dddkrdSdS)N connectioncloseF http_version1.1T)rheadersgetattr)r5 connectionr1r1r2 _keep_aliveTs r>request_methodr1cCst|ttfvs Jt|tur4|jdvs+|dks+|dkr-d|jkr)dkr-dSndS|jdks4Jt|jd}|rE|dgksCJd St|jd }|rVd t|d ffSt|tur^dSd S)N)i0HEADCONNECT,)content-length)rtransfer-encodingchunked)chunkedr1content-lengthrEr)http/1.0r1)typerr status_coderr;int)r?r5Ztransfer_encodingsZcontent_lengthsr1r1r2 _body_framing]s&     rNc @sReZdZdZefdeededdfddZe de eeeeffdd Z e deefd d Z e deefd d Z e defddZd6ddZdeeddfddZdedeeefddZdeededdfddZdeedeedeeefdeedeffddZ d7de eeeefdeeddfdd Ze deeeffd!d"Zd#eddfd$d%Z deeee!ee"ffd&d'Z#deeee!ee"ffd(d)Z$e%de&ddfd*d+Z'e%dee(e)e*e+e,fdefd,d+Z'e%dedeefd-d+Z'dedeefd.d+Z'dedee-efd/d0Z.d6d1d2Z/d3e*de*fd4d5Z0dS)8r)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_sizer6NcCs||_|ttfvrtd|||_||turt|_nt|_t|_||jdt |_ ||jdt |_ t |_d|_d|_d|_d|_dS)Nzexpected CLIENT or SERVER, not F)_max_incomplete_event_sizerr" ValueErrorrO their_roler_cstate_get_io_objectr'_writerr_readerr_receive_buffer_receive_buffer_closedtheir_http_version_request_method"client_is_waiting_for_100_continue)selfrOrPr1r1r2__init__s   zConnection.__init__cCs t|jjS)zA dictionary like:: {CLIENT: , SERVER: } See :ref:`state-machine` for details. )dictrTstatesr]r1r1r2r`s zConnection.statescC|jj|jS)zjThe current state of whichever role we are playing. See :ref:`state-machine` for details. )rTr`rOrar1r1r2 our_statezConnection.our_statecCrb)znThe current state of whichever role we are NOT playing. See :ref:`state-machine` for details. )rTr`rSrar1r1r2 their_staterdzConnection.their_statecCs|jtuo|jSN)rSrr\rar1r1r2!they_are_waiting_for_100_continuesz,Connection.they_are_waiting_for_100_continuecCs4t|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)r_rTr`start_next_cycler[r\_respond_to_state_changes)r] old_statesr1r1r2rhs  zConnection.start_next_cyclerolecCs&t|jj}|j|||dSrf)r_rTr`Z process_errorri)r]rkrjr1r1r2_process_errors  zConnection._process_errorr5cCsTt|tur |jdkr tSt|tur(t|jjvr(d|jkr%dkr(tSdSdS)NerCrD)rKrrLrrrrTZpending_switch_proposalsr]r5r1r1r2_server_switch_events  zConnection._server_switch_eventcCsRt|jj}|tur't|tur'|jdkr|jtt |j dr'|jt d}|t ur2| |}|j|t||t|turF|j|_||jurbt|tttfvrbtttttf|}|j|_t|ttfvrztttttf|sz|jt|turt|rd|_t|ttfvrd|_|turt|ttfvrd|_|||dS)NrBsupgradeTF)r_rTr`rrKrmethodZprocess_client_switch_proposalrrr;rr"roZ process_eventr[rSrrrr r9rZr>Zprocess_keep_alive_disabledrr\rrri)r]rkr5rjZserver_switch_eventr1r1r2_process_events<        zConnection._process_eventio_dict.cCsV|jj|}|tur$ttt|jtttt f|\}}|t||S| ||fSrf) rTr`r!rNrbytesr[r rrget)r]rkr5rrstate framing_typeargsr1r1r2rU@s zConnection._get_io_objectrjcCsL|j||jkr||j|t|_|j||jkr$||j|t|_dSdSrf) rcrOrUr'rVrerSrrW)r]rjr5r1r1r2riVs z$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. )rsrXrYrar1r1r2 trailing_dataas zConnection.trailing_datadatacCs.|r|jr td|j|7_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)rY RuntimeErrorrX)r]ryr1r1r2 receive_datals ' zConnection.receive_datacCs|j}|tur |jr tS|tus|turtS|jdusJ||j}|dur<|js<|jr` 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]r5 data_listr1r1r2rs  cCs|jtur tdz/t|tur||}|j}||j|t|t ur(WdS|dus.Jg}|||j |WS| |j)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) rcrr$rKr&_clean_up_response_headers_for_sendingrVrqrOr appendrl)r]r5writerrr1r1r2r 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)rlrOrar1r1r2 send_failedAszConnection.send_failedresponsecCst|tusJ|j}d}tt|j}|dkrd}t||\}}|dvrIt|dg}|jdus4|jdkrBt|dg}|jdkrAd}nt|dd g}|j j rO|rht t |d }| d |d t|d t|}t||j|j|jd S)NFrAsGET)rHrJrIr:rFTrGr7s keep-aliver8)r;rLr9reason)rKrr;rrsr[rNrrZrT keep_alivesetrdiscardaddsortedrLr9r)r]rr;Z need_closeZmethod_for_choosing_headersrv_r=r1r1r2rZs4       z1Connection._clean_up_response_headers_for_sending)r6Nrf)1r.r/r0__doc__!DEFAULT_MAX_INCOMPLETE_EVENT_SIZEr r&rMr^propertyrr`rcreboolrgrhrlrrrorqr rr(rrrUrir rsrxr{r*r+r~rrr rrrrrrrrrrr1r1r1r2r)sx '    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>rsstrrMrNr)r1r1r1r2s*0$   0    :