}DjGPdZddlmZmZddlmZddlmZmZddl m Z m Z m Z m Z mZddlmZddlmZddlmZd d lmZmZd d lmZmZmZd d lmZmZmZd d l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+d dl,m-Z-ddgZ.e reZ/ne0Z/ee1Z2Gdde/Z3Gdde3eZ4dedefdZ5y)zDMain classes to add caching features to :py:class:`requests.Session`)contextmanager nullcontext) getLogger)RLockThread) TYPE_CHECKINGIterableMutableMappingOptionalUnion)PreparedRequest)Session) dispatch_hook)get_valid_kwargspatch_form_boundary)BackendSpecifier StrOrPath init_backend) AnyResponseCachedResponseOriginalResponse) DEFAULT_CACHE_NAMEDEFAULT_IGNORED_PARAMSDEFAULT_METHODSDEFAULT_STATUS_CODES CacheActions CacheSettingsExpirationPatternsExpirationTimeFilterCallback KeyCallbackset_request_headers)SerializerType CachedSession CacheMixinc#eZdZdZeddddddeededdddddfdede e de e d e d e e d ed e ed eedeededeedeeeefde ede ededeeefdef"fd ZededdfdZedefdZej8defdZede fdZej8de fdZd;d edefd!Zd edefd"Z d edefd#Z!d;d edefd$Z"d;d edefd%Z#d;d edefd&Z$d edefd'Z%dddddd(d)ed ed*e e&eefd e d+ed,ed-edeffd.Z' d >)00*22)00,66)00rFc.|jjS)z#Settings that affect cache behaviorr< _settingsrBs rEr>zCacheMixin.settingspszz###rFvaluec&||j_yNrZrBr]s rEr>zCacheMixin.settingsus$ rFc.|jjSr_r>r,r\s rEr,zCacheMixin.expire_afterzs}})))rFc&||j_yr_rbr`s rEr,zCacheMixin.expire_after~s%* "rFurlc R|jdd|jd|fd|i|S)Nallow_redirectsTGETrQ setdefaultrequest)rBrdrQrCs rEgetzCacheMixin.gets0+T2t||E3@v@@@rFc N|jdd|jd|fi|S)NrfTOPTIONSrhrBrdrCs rEoptionszCacheMixin.optionss++T2t||Is5f55rFc N|jdd|jd|fi|S)NrfFHEADrhrns rEheadzCacheMixin.heads++U3t||FC2622rFc .|jd|fd|i|S)NPOSTdatarjrBrdrurCs rEpostzCacheMixin.postst||FC=d=f==rFc .|jd|fd|i|S)NPUTrurvrws rEputzCacheMixin.putst||E3t>v>>rFc *|jd|fi|S)NDELETErvrns rEdeletezCacheMixin.deletest||Hc4V44rF)rNr,only_if_cachedrefresh force_refreshmethodrNrrrct|||||}| jdr tn t5t |||g|d|i| cdddS#1swYyxYw)aYThis method prepares and sends a request while automatically performing any necessary caching operations. This will be called by any other method-specific ``requests`` functions (get, post, etc.). This is not used by :py:class:`~requests.PreparedRequest` objects, which are handled by :py:meth:`send()`. See :py:meth:`requests.Session.request` for base parameters. Additional parameters: Args: expire_after: Expiration time to set only for this request. See :ref:`expiration` for details. only_if_cached: Only return results from the cache. If not cached, return a 504 response instead of sending a new request. refresh: Revalidate with the server before using a cached response, and refresh if needed (e.g., a "soft refresh," like F5 in a browser) force_refresh: Always make a new request, and overwrite any previously cached response (e.g., a "hard refresh", like Ctrl-F5 in a browser)) Returns: Either a new or cached response filesrNN)r#rkrrr@rj) rBrrdrNr,rrrargsrCrDs rErjzCacheMixin.requestse@&g|^WVcd&,jj&9 "{} R7?63QQwQ&Q R R Rs AArjc t|j|||||_tj|jj |fi|||j }d}|js%|jj|j}|j||jj fi||jr|j} |jj| } | |_ | Td|_ d|_ d|_d|_d|_ i|_|j| |jj fi|| }|jr t#|} nj|jr|j$|||fi||} nF|jr|j&|||fi|} n$|jr|j(|||fi|} n|} |j j*d|j j+| sIt,j/d| j0|jj3|j| St5d|j6| fi|S)aSend a prepared request, with caching. See :py:meth:`requests.Session.send` for base parameters, and see :py:meth:`.request` for extra parameters. **Order of operations:** For reference, a request will pass through the following methods: 1. :py:func:`requests.get`, :py:meth:`CachedSession.get`, etc. (optional) 2. :py:meth:`.CachedSession.request` 3. :py:meth:`requests.Session.request` 4. :py:meth:`.CachedSession.send` 5. :py:meth:`.BaseCache.get_response` 6. :py:meth:`requests.Session.send` (if not using a cached response) 7. :py:meth:`.BaseCache.save_response` (if not using a cached response) NFz$Deleting filtered response for URL: response)r#rNr from_requestr< create_keyr> skip_read get_response cache_keyupdate_from_cached_responsevary_cache_key send_requestresend_request resend_async error_504_validation_headersget_504_response _resend_async_resend_send_and_cacher5loggerdebugrdrrrO) rBrjr,rrrrCactionscached_responsevary_key vary_cachedrs rEsendzCacheMixin.sends'.. OO\>7M ++ !DJJ ! !' 4V 4gt}}  59  "jj55g6G6GHO+++OTZZ=R=R]V\]  ! !--H**11(;K (G &',$).&',$$)!)-&.0+333KAVAVaZ`a"-   $4W$=H  ! ! D  w KF K&H  # ##t||GWoPPH  ! !+t++GWoXQWXH&H == " " .t}}7N7Nx7X LL? ~N O JJ  g// 0OZKFKKrFrrc <|j|}t||fi|}|j||js2|j j ||j|jn|`|jdk(rQ|j||}|js1|j j ||j|j|Stjd|jt|tr|St!j"||S)zSend a request and cache the response, unless disabled by settings or headers. If applicable, also handle conditional requests. i0zSkipping cache write for URL: )update_requestr@rupdate_from_response skip_writer< save_responserexpires status_codeupdate_revalidated_responserrrd isinstancerr wrap_response)rBrjrrrCrrDs rErzCacheMixin._send_and_cache s((17<262$$X.!! JJ $ $Xw/@/@'// R  (X-A-AS-H%AA(O\O%% ((':K:KW__]" " LL9'++G H h /O#11(GD DrFc .tjd |j|||fi|}|jjr2|j |jj vr|j|S#t$r|j||cYSwxYw)znHandle a stale cached response by attempting to resend the request and cache a fresh response z-Stale response; attempting to re-send request) rrrr>r8rr0raise_for_status Exception _handle_error)rBrjrrrCrs rErzCacheMixin._resend+s  DE @+t++GWoXQWXH ,,(( 0M0MM))+O @%%ow? ? @sAA66BBc~tjdt|j||}|j y)z8Send a non-blocking request to refresh a cached responsez'Using stale response while revalidating)targetrrCN)rrrrstart)rBrrCthreads rErzCacheMixin._resend_asyncAs, >?t33$vN rFc|j|dr1tjd|jjdd|S)zHandle a request error based on settings: * Default behavior: re-raise the error * stale-if-error: Ignore the error and and return the stale cache item T)errorzRequest for URL z failed; using cached response)exc_info) is_usablerwarningrjrd)rBrrs rErzCacheMixin._handle_errorGsP   _D  9 NN"?#:#:#>#>"??]^  # " rFc#K|jjrdyd|j_ dd|j_y#d|j_wxYww)a Context manager for temporary disabling the cache .. warning:: This method is not thread-safe. Example: >>> s = CachedSession() >>> with s.cache_disabled(): ... s.get('https://httpbin.org/ip') NTF)r>disabledr\s rEcache_disabledzCacheMixin.cache_disabledUsD == ! ! %)DMM " /). & &s-AAAAAct||jjr|jjyy)z2Close the session and any open backend connectionsN)r@closer>r9r<)rBrDs rErzCacheMixin.closels.   == " " JJ    #rFctd)NzCachedSession cannot be pickled)NotImplementedErrorr\s rE __getstate__zCacheMixin.__getstate__rs""CDDrFcNdt|jd|jdS)Nz)reprr<r>r\s rE__repr__zCacheMixin.__repr__xs&&tDJJ'7&8 DMM?RTUUrFr_)NFFF)6__name__ __module__ __qualname____doc__rrrrrr rr$r rboolstrr intr r!r"rA classmethodOriginalSessionrXpropertyrr>setterr,rrkrorrrxr{r~rr rjr rrrrrrrrrrrr __classcell__)rDs@rEr&r&'s !3.2/3'):>#*.)=+:"',B49.2(,+0%*G*G*+*G^, *G % *G $$67 *G*G#3-*G"#*G$C=*G *G%SM*GXc]D01*GN+*G%*G !*G"dCi(#*G$%*GXO,.$-$$__%m%%*n**+.++AsAkA636[633+3>>[>=s=K=??k?5#5K57;'+$#"R"R"R .c23 "R % "R"R"R"R "RN(,$# KL KL%KL KL  KL  KL KLb59 E EE".1 E  E>@ @@( @  @, ^ l Wb //, E VrFceZdZdZy)r%a@ Session class that extends :py:class:`requests.Session` with caching features. See individual :py:mod:`backend classes ` for additional backend-specific arguments. Also see :ref:`user-guide` for more details and examples on how the following arguments affect cache behavior. Args: cache_name: Used as a cache path, prefix, or namespace, depending on the backend backend: Cache backend name or instance; name may be one of ``['sqlite', 'filesystem', 'mongodb', 'gridfs', 'redis', 'dynamodb', 'memory']`` serializer: Serializer name or instance; name may be one of ``['pickle', 'json', 'yaml', 'bson']``. expire_after: Time after which cached items will expire. See :ref:`expiration` for details. urls_expire_after: Expiration times to apply for different URL patterns cache_control: Use Cache-Control and other response headers to set expiration allowable_codes: Only cache responses with one of these status codes allowable_methods: Cache only responses for one of these HTTP methods always_revalidate: Revalidate with the server for every request, even if the cached response is not expired match_headers: Request headers to match, when `Vary` response header is not available. May be a list of headers, or ``True`` to match all. ignored_parameters: Request parameters, headers, and/or JSON body params to exclude from both request matching and cached request data read_only: Read existing cached responses, but do not write any new responses to the cache stale_if_error: Return a stale response if a new request raises an exception. Optionally accepts a time value representing maximum staleness to accept. stale_while_revalidate: Return a stale response initially, while a non-blocking request is sent to refresh the response for the next time it's requested autoclose: Close the cache backend when the session is closed filter_fn: Response filtering function that indicates whether or not a given response should be cached. See :ref:`custom-filtering` for details. key_fn: Request matching function for generating custom cache keys. See :ref:`custom-matching` for details. N)rrrrr;rFrEr%r%|s!rFrjrHc<t|jxsddd|S)zHGet a 504: Not Cached error response, for use with only-if-cached optioniz Not Cached)rdrreasonrj)rrdrvs rErrs$  KK 2  rFN)6r contextlibrrloggingr threadingrrtypingrr r r r requestsr rrrequests.hooksr_utilsrrbackendsrrrmodelsrrrpolicyrrrrrrrr r!r"r# serializersr$__all__ MIXIN_BASEobjectrrr&r%rr;rFrErsJ2#KK$/(9??AA    ( L ) JJ 8 RVRVj "J"Jo.rF