fume-manage-python.git

U  
I=®drã@s dZddlZddlZddlZddlmZddlmZddlm    Z    ddl
mZmZm Z mZmZddlmZmZmZmZdd    lmZmZmZdd
lmZmZddlmZddlmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&ddl'm(Z(ddl)m*Z*ddlm+Z+m,Z,m-Z-m.Z.m/Z/m0Z0ddl1m2Z2ddlm3Z3ej4dkrVz
ej5Z6Wne7k
rRej8Z6YnXnejZ6efddZ9efddZ:Gddde;Z<Gddde<Z=ddZ>dS)z
requests.session
~~~~~~~~~~~~~~~~
 
This module provides a Session object to manage and persist settings across
requests (cookies, auth, proxies).
éN)Ú    timedelta)ÚOrderedDicté)Ú_basic_auth_str)Ú    cookielibÚis_py3ÚurljoinÚurlparseÚMapping)Úcookiejar_from_dictÚextract_cookies_to_jarÚRequestsCookieJarÚ merge_cookies)ÚRequestÚPreparedRequestÚDEFAULT_REDIRECT_LIMIT)Ú default_hooksÚ dispatch_hook)Úto_native_string)Úto_key_val_listÚdefault_headersÚ DEFAULT_PORTS)ÚTooManyRedirectsÚ InvalidSchemaÚChunkedEncodingErrorÚContentDecodingError)ÚCaseInsensitiveDict)ÚHTTPAdapter)Úrequote_uriÚget_environ_proxiesÚget_netrc_authÚshould_bypass_proxiesÚget_auth_from_urlÚrewind_body)Úcodes)ÚREDIRECT_STATIÚwin32cCsp|dkr|S|dkr|St|tr,t|ts0|S|t|}| t|¡dd| ¡D}|D]
}||=q`|S)zèDetermines appropriate setting for a given request, taking into account
    the explicit setting on that request, and the setting in the session. If a
    setting is a dictionary, they will be merged together using `dict_class`
    NcSsg|]\}}|dkr|qS©N©)Ú.0ÚkÚvr(r(úTD:\z\workplace\VsCode\pyvenv\venv\Lib\site-packages\pip/_vendor/requests/sessions.pyÚ
<listcomp>Jsz!merge_setting.<locals>.<listcomp>)Ú
isinstancer
rÚupdateÚitems)Úrequest_settingÚsession_settingÚ
dict_classÚmerged_settingÚ    none_keysÚkeyr(r(r,Ú merge_setting2sÿþr7cCs@|dks| d¡gkr|S|dks0| d¡gkr4|St|||S)z©Properly merges both requests and session hooks.
 
    This is necessary because when request_hooks == {'response': []}, the
    merge breaks Session hooks entirely.
    NÚresponse)Úgetr7)Ú request_hooksÚ session_hooksr3r(r(r,Úmerge_hooksQs
r<c@s>eZdZddZddZddd    Zd
dZdd ZddZdS)ÚSessionRedirectMixincCs,|jr(|jd}tr| d¡}t|dSdS)z7Receives a Response. Returns a redirect URI or ``None``ÚlocationÚlatin1Úutf8N)Úis_redirectÚheadersrÚencoder)ÚselfÚrespr>r(r(r,Úget_redirect_targetbs
 
 
z(SessionRedirectMixin.get_redirect_targetcCst|}t|}|j|jkr dS|jdkrL|jdkrL|jdkrL|jdkrLdS|j|jk}|j|jk}t |jd¡df}|s|j|kr|j|krdS|p|S)zFDecide whether Authorization header should be removed when redirectingTÚhttp)éPNÚhttps)i»NFN)r    ÚhostnameÚschemeÚportrr9)rDÚold_urlÚnew_urlÚ
old_parsedÚ
new_parsedÚchanged_portÚchanged_schemeÚdefault_portr(r(r,Úshould_strip_authws$ÿÿÿz&SessionRedirectMixin.should_strip_authFNTc    
ksHg}
| |¡}t|jj}|rD| ¡} |
 |¡|
dd|_z
|jWn(tt    t
fk
rr|jjddYnXt |j|jkrtd |j¡|d| ¡| d¡rÈt|j}d t|j|g¡}t|}|jd    krì|rì|j|d
}n|jrø|j}| ¡}|jst|jt|}nt|}t|| _| | |¡|jtjtjfkrpd}|D]}| j  !|d¡qTd| _"| j }| !dd¡t#| j$||jt%| j$|j&|  '| j$¡| (| |¡}| )| |¡| j*dk    oàd |kpàd|k}|rðt+| | }|r|Vq|j,|f|||||dd|    }t#|j&| |j| |¡}|VqdS)zBReceives a Response. Returns a generator of Responses or Requests.rNF)Údecode_contentzExceeded {} redirects.)r8z//ú:Ú)Úfragment)úContent-LengthzContent-TypeúTransfer-EncodingÚCookierYrZ)ÚstreamÚtimeoutÚverifyÚcertÚproxiesÚallow_redirects)-rFr    ÚurlrXÚcopyÚappendÚhistoryÚcontentrrÚRuntimeErrorÚrawÚreadÚlenÚ max_redirectsrÚformatÚcloseÚ
startswithÚjoinrrKÚ_replaceÚgeturlÚnetlocrrÚrebuild_methodÚstatus_coder$Útemporary_redirectÚpermanent_redirectrBÚpopÚbodyrÚ_cookiesrÚcookiesÚprepare_cookiesÚrebuild_proxiesÚrebuild_authÚ_body_positionr#Úsend)rDrEÚreqr\r]r^r_r`Úyield_requestsÚadapter_kwargsÚhistrbÚprevious_fragmentÚprepared_requestÚparsed_rurlÚparsedÚpurged_headersÚheaderrBÚ
rewindabler(r(r,Úresolve_redirectss~
 
 
 
 
 
þÿùø
z&SessionRedirectMixin.resolve_redirectscCsR|j}|j}d|kr*| |jj|¡r*|d=|jr8t|nd}|dk    rN| |¡dS)zéWhen being redirected we may want to strip authentication from the
        request to avoid leaking credentials. This method intelligently removes
        and reapplies authentication where possible to avoid credential loss.
        Ú AuthorizationN)rBrbrTÚrequestÚ    trust_envr Úprepare_auth)rDrr8rBrbÚnew_authr(r(r,r}þsz!SessionRedirectMixin.rebuild_authc CsÖ|dk    r|ni}|j}|j}t|j}| ¡}| d¡}t||d}|jr||s|t||d}    |     ||     d¡¡}
|
r||     ||
¡d|kr|d=zt
||\}}Wntk
rºd\}}YnX|rÒ|rÒt|||d<|S)a°This method re-evaluates the proxy configuration by considering the
        environment variables. If we are redirected to a URL covered by
        NO_PROXY, we strip the proxy configuration. Otherwise, we set missing
        proxy keys for this URL (in case they were stripped by a previous
        redirect).
 
        This method also replaces the Proxy-Authorization header where
        necessary.
 
        :rtype: dict
        NÚno_proxy©rÚallzProxy-Authorization)NN) rBrbr    rKrcr9r!rrÚ
setdefaultr"ÚKeyErrorr) rDrr`rBrbrKÚnew_proxiesrÚbypass_proxyÚenviron_proxiesÚproxyÚusernameÚpasswordr(r(r,r|s*
 
 
z$SessionRedirectMixin.rebuild_proxiescCsX|j}|jtjkr|dkrd}|jtjkr6|dkr6d}|jtjkrN|dkrNd}||_dS)zWhen being redirected we may want to change the method of the request
        based on certain specs or browser behavior.
        ÚHEADÚGETÚPOSTN)Úmethodrtr$Ú    see_otherÚfoundÚmoved)rDrr8rr(r(r,rs:sz#SessionRedirectMixin.rebuild_method)FNTNNF)    Ú__name__Ú
__module__Ú__qualname__rFrTrr}r|rsr(r(r(r,r=`sÿ
n)r=c@sÌeZdZdZdddddddd    d
ddd gZddZddZddZddZd6ddZ    ddZ
ddZddZd7d d!Z d8d"d#Zd9d$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5ZdS):ÚSessionaA Requests session.
 
    Provides cookie persistence, connection-pooling, and configuration.
 
    Basic Usage::
 
      >>> import requests
      >>> s = requests.Session()
      >>> s.get('https://httpbin.org/get')
      <Response [200]>
 
    Or as a context manager::
 
      >>> with requests.Session() as s:
      ...     s.get('https://httpbin.org/get')
      <Response [200]>
    rBrzÚauthr`ÚhooksÚparamsr^r_Úadaptersr\rrkcCsrt|_d|_i|_t|_i|_d|_d|_d|_    t
|_d|_t i|_t|_| dt¡| dt¡dS)NFTzhttps://zhttp://)rrBr§r`rr¨r©r\r^r_rrkrrrzrrªÚmountr©rDr(r(r,Ú__init__js
zSession.__init__cCs|Sr'r(r¬r(r(r,Ú    __enter__¡szSession.__enter__cGs| ¡dSr')rm)rDÚargsr(r(r,Ú__exit__¤szSession.__exit__c Cs²|jpi}t|tjst|}ttt|j|}|j}|jrR|sR|jsRt    |j
}t}|j|j  ¡|j
|j|j|jt|j|jtdt|j|jt||j|t|j|jd
|S)aConstructs a :class:`PreparedRequest <PreparedRequest>` for
        transmission and returns it. The :class:`PreparedRequest` has settings
        merged from the :class:`Request <Request>` instance and those of the
        :class:`Session`.
 
        :param request: :class:`Request` instance to prepare with this
            session's settings.
        :rtype: requests.PreparedRequest
        )r3)
rrbÚfilesÚdataÚjsonrBr©r§rzr¨)rzr.rÚ    CookieJarrrr r§rr rbrÚpreparerÚupperr±r²r³r7rBrr©r<r¨)rDrrzÚmerged_cookiesr§Úpr(r(r,Úprepare_request§s0
 
ÿ
 
özSession.prepare_requestNTcCstt| ¡||||pi||pi|||d
}| |¡}|p8i}| |j|| ||¡}|    |
d}| |¡|j|f|}|S)aConstructs a :class:`Request <Request>`, prepares it and sends it.
        Returns :class:`Response <Response>` object.
 
        :param method: method for the new :class:`Request` object.
        :param url: URL for the new :class:`Request` object.
        :param params: (optional) Dictionary or bytes to be sent in the query
            string for the :class:`Request`.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param json: (optional) json to send in the body of the
            :class:`Request`.
        :param headers: (optional) Dictionary of HTTP Headers to send with the
            :class:`Request`.
        :param cookies: (optional) Dict or CookieJar object to send with the
            :class:`Request`.
        :param files: (optional) Dictionary of ``'filename': file-like-objects``
            for multipart encoding upload.
        :param auth: (optional) Auth tuple or callable to enable
            Basic/Digest/Custom HTTP Auth.
        :param timeout: (optional) How long to wait for the server to send
            data before giving up, as a float, or a :ref:`(connect timeout,
            read timeout) <timeouts>` tuple.
        :type timeout: float or tuple
        :param allow_redirects: (optional) Set to True by default.
        :type allow_redirects: bool
        :param proxies: (optional) Dictionary mapping protocol or protocol and
            hostname to the URL of the proxy.
        :param stream: (optional) whether to immediately download the response
            content. Defaults to ``False``.
        :param verify: (optional) Either a boolean, in which case it controls whether we verify
            the server's TLS certificate, or a string, in which case it must be a path
            to a CA bundle to use. Defaults to ``True``.
        :param cert: (optional) if String, path to ssl client cert file (.pem).
            If Tuple, ('cert', 'key') pair.
        :rtype: requests.Response
        )
rrbrBr±r²r³r©r§rzr¨)r]ra)rr¶r¹Úmerge_environment_settingsrbr/r)rDrrbr©r²rBrzr±r§r]rar`r¨r\r^r_r³rÚprepÚsettingsÚsend_kwargsrEr(r(r,rÏs6)ö
ÿþ
zSession.requestcKs| dd¡|jd|f|S)zåSends a GET request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        raTr©rr©rDrbÚkwargsr(r(r,r9szSession.getcKs| dd¡|jd|f|S)zéSends a OPTIONS request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        raTÚOPTIONSr¾r¿r(r(r,Úoptions!szSession.optionscKs| dd¡|jd|f|S)zæSends a HEAD request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        raFrr¾r¿r(r(r,Úhead,szSession.headcKs|jd|f||d|S)aÈSends a POST request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param json: (optional) json to send in the body of the :class:`Request`.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        r)r²r³©r)rDrbr²r³rÀr(r(r,Úpost7szSession.postcKs|jd|fd|i|S)auSends a PUT request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        ÚPUTr²rÄ©rDrbr²rÀr(r(r,ÚputDs
zSession.putcKs|jd|fd|i|S)awSends a PATCH request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param data: (optional) Dictionary, list of tuples, bytes, or file-like
            object to send in the body of the :class:`Request`.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        ÚPATCHr²rÄrÇr(r(r,ÚpatchPs
z Session.patchcKs|jd|f|S)zèSends a DELETE request. Returns :class:`Response` object.
 
        :param url: URL for the new :class:`Request` object.
        :param \*\*kwargs: Optional arguments that ``request`` takes.
        :rtype: requests.Response
        ÚDELETErÄr¿r(r(r,Údelete\szSession.deletec Ks|| d|j¡| d|j¡| d|j¡| d|j¡t|trJtd| dd¡}|     d¡}|j
}|j|jd}t }|j|f|}t |}    t|    d    |_td
||f|}|jrÒ|jD]}
t|j|
j|
jqºt|j||j|r|j||f|}dd|D}ng}|r,| d |¡| ¡}||_|slz"t|j||fddi||_Wntk
rjYnX|sx|j|S)zISend a given PreparedRequest.
 
        :rtype: requests.Response
        r\r^r_r`z#You can only send PreparedRequests.raT)rb)Úsecondsr8cSsg|]}|qSr(r()r)rEr(r(r,r-sz Session.send.<locals>.<listcomp>rr)rr\r^r_r`r.rÚ
ValueErrorrwr9r¨Úget_adapterrbÚpreferred_clockrrÚelapsedrrerrzrrhrÚinsertÚnextÚ_nextÚ StopIterationrf) rDrrÀrar\r¨ÚadapterÚstartÚrrÑrEÚgenrer(r(r,rfsF
 
 
 
"zSession.sendc
Cs¬|jrn|dk    r| d¡nd}t||d}| ¡D]\}}    | ||    ¡q0|dksV|dkrntj d¡pltj d¡}t||j}t||j    }t||j
}t||j}||||dS)z^
        Check the environment and merge it with some settings.
 
        :rtype: dict
        NrrTÚREQUESTS_CA_BUNDLEÚCURL_CA_BUNDLE)r^r`r\r_)rr9rr0rÚosÚenvironr7r`r\r^r_)
rDrbr`r\r^r_rÚenv_proxiesr*r+r(r(r,rº±s 
ÿÿz"Session.merge_environment_settingscCs@|j ¡D]"\}}| ¡ | ¡¡r
|Sq
td |¡dS)z~
        Returns the appropriate connection adapter for the given URL.
 
        :rtype: requests.adapters.BaseAdapter
        z*No connection adapters were found for {!r}N)rªr0Úlowerrnrrl)rDrbÚprefixrÖr(r(r,rÏÎs
zSession.get_adaptercCs|j ¡D]}| ¡q
dS)z+Closes all adapters and as such the sessionN)rªÚvaluesrm)rDr+r(r(r,rmÜsz Session.closecs>||j<fdd|jD}|D]}|j |¡|j|<q"dS)zwRegisters a connection adapter to a prefix.
 
        Adapters are sorted in descending order by prefix length.
        cs g|]}t|tkr|qSr()rj)r)r*©ràr(r,r-çsz!Session.mount.<locals>.<listcomp>N)rªrw)rDràrÖÚkeys_to_mover6r(râr,r«ás
z Session.mountcsfddjD}|S)Ncsi|]}|t|dqSr')Úgetattr)r)Úattrr¬r(r,Ú
<dictcomp>ísz(Session.__getstate__.<locals>.<dictcomp>)Ú    __attrs__)rDÚstater(r¬r,Ú__getstate__ìszSession.__getstate__cCs"| ¡D]\}}t|||qdSr')r0Úsetattr)rDrèråÚvaluer(r(r,Ú__setstate__ðszSession.__setstate__)NNNNNNNTNNNNNN)NN)N)N)r£r¤r¥Ú__doc__rçrr®r°r¹rr9rÂrÃrÅrÈrÊrÌrrºrÏrmr«rérìr(r(r(r,r¦Qs^ý7)ý
G
 
 
 
Kr¦cCstS)aZ
    Returns a :class:`Session` for context-management.
 
    .. deprecated:: 1.0.0
 
        This method has been deprecated since version 1.0.0 and is only kept for
        backwards compatibility. New code should use :class:`~requests.sessions.Session`
        to create a session. This may be removed at a future date.
 
    :rtype: Session
    )r¦r(r(r(r,Úsessionõsrî)?rírÜÚsysÚtimeÚdatetimerÚcollectionsrr§rÚcompatrrrr    r
rzrrr rÚmodelsrrrr¨rrÚ_internal_utilsrÚutilsrrrÚ
exceptionsrrrrÚ
structuresrrªrrrr r!r"r#Ústatus_codesr$r%ÚplatformÚperf_counterrÐÚAttributeErrorZclockr7r<Úobjectr=r¦rîr(r(r(r,Ú<module>sB 
r'