gNUdZddlmZddlZddlZddlZddlZddlZddlZddl m Z ddl m Z ddl mZmZmZmZddlmZddlmZdd lmZdd lmZdd lmZmZmZmZmZm Z m!Z!dd l"m#Z#m$Z$m%Z%m&Z&dd l'm(Z(m)Z)ddl*m+Z+ddl,m-Z-er ddl.m/Z/ddl0m1Z1ee2Z3de4d<ejjZ6GddZ7GddZ8d dZ9GddZ:GddZ; d!dZy)$zACommon cache logic shared by st.cache_data and st.cache_resource.) annotationsN)abstractmethod) defaultdict) TYPE_CHECKINGAnyCallableFinal) type_util)is_unevaluated_data_object)spinner) get_logger) CacheErrorCacheKeyNotFoundErrorUnevaluatedDataFrameErrorUnhashableParamErrorUnhashableTypeErrorUnserializableReturnValueErrorget_cached_func_name_md)CachedMessageReplayContext CachedResultMsgDatareplay_cached_messages) HashFuncsDict update_hash)in_cached_function)HASHLIB_KWARGS) FunctionType) CacheTyper _LOGGERc`eZdZdZdZed dZed dZd dZd d dZ ed ddZ y)Cachez>7R!*!1ct)zRead a value and associated messages from the cache. Raises ------ CacheKeyNotFoundError Raised if value_key is not in the cache. NotImplementedErrorr) value_keys r* read_resultzCache.read_resultIs "!r,ct)z}Write a value and associated messages to the cache, overwriting any existing result that uses the value_key. r.)r)r1valuemessagess r* write_resultzCache.write_resultUs "!r,cd|j5|j|cdddS#1swYyxYw)apReturn the lock that should be held while computing a new cached value. In a popular app with a cache that hasn't been pre-warmed, many sessions may try to access a not-yet-cached value simultaneously. We use a lock to ensure that only one of those sessions computes the value, and the others block until the value is computed. N)r'r&r0s r*compute_value_lockzCache.compute_value_lock^s' # #$$Y/$ # #s&/Nc|j5|s|jjn||jvr |j|=ddd|j|y#1swYxYw)zClear values from this cache. If no argument is passed, all items are cleared from the cache. A key can be passed to clear that key from the cache only.Nkey)r'r&clear_clearr)r;s r*r<z Cache.clearhs\ # #!!''))))%%c* $   $ #s 9A!!A*ct)z?Subclasses must implement this to perform cache-clearing logic.r.r>s r*r=z Cache._clearss "!r,)r1strreturnr)r1r@r4rr5z list[MsgData]rANone)r1r@rAzthreading.Lockr#)r; str | None)r;rCrArB) __name__ __module__ __qualname____doc__r+rr2r6r8r<r=r,r*r!r!BsPF2 " """0 ""r,r!cPeZdZdZ ddZeddZed dZd dZy) CachedFuncInfozEncapsulates data for a cached function instance. CachedFuncInfo instances are scoped to a single script run - they're not persistent. c.||_||_||_yr#)func show_spinner hash_funcs)r)rLrMrNs r*r+zCachedFuncInfo.__init__s  ($r,ctr#r.r(s r* cache_typezCachedFuncInfo.cache_type!!r,ctr#r.r(s r*cached_message_replay_ctxz(CachedFuncInfo.cached_message_replay_ctxrQr,ct)z3Get or create the function cache for the given key.r.)r) function_keys r*get_function_cachez!CachedFuncInfo.get_function_cacherQr,N)rLrrMz bool | strrNHashFuncsDict | None)rAr)rAr)rUr@rAr!) rDrErFrGr+propertyrPrSrVrHr,r*rJrJysU %%!%) %"""""r,rJcXt|}tj||jS)aaCreate a callable wrapper around a CachedFunctionInfo. Calling the wrapper will return the cached value if it's already been computed, and will call the underlying function to compute and cache the value otherwise. The wrapper also has a `clear` function that can be called to clear some or all of the wrapper's cached values. ) CachedFunc functoolsupdate_wrapperrL)info cached_funcs r*make_cached_func_wrapperr_s%T"K  # #K ;;r,c,eZdZdZddZddZdZdZy) BoundCachedFunczwA wrapper around a CachedFunc that binds it to a specific instance in case of decorated function is a class method.c ||_||_yr# _cached_func _instance)r)r^instances r*r+zBoundCachedFunc.__init__s'!r,cB|j|jg|i|Sr#rcr)argskwargss r*__call__zBoundCachedFunc.__call__s# t  A$A&AAr,cdd|jjjd|jdS)Nz)rd_inforLrer(s r*__repr__zBoundCachedFunc.__repr__s0#D$5$5$;$;$@$@#AdnnEUUVWWr,c|s|r+|jj|jg|i|y|jjyr#)rdr<rerhs r*r<zBoundCachedFunc.clearsA 6 $D   # #DNN DT DV D    # # %r,N)r^rZrfrrAr)rDrErFrGr+rkror<rHr,r*raras-"BX&r,racneZdZd dZdZd dZd dZ d d dZddZ ddZ d Z y)rZc\||_t|j|j|_yr#)rn_make_function_keyrPrL _function_key)r)r]s r*r+zCachedFunc.__init__s  /Kr,c6d|jjdS)Nz DD%ct||jj|jj|jS)zVHandle a cache hit: replay the result's cached messages, and return its value.)rrnrPrLr4)r)results r*rzCachedFunc._handle_cache_hits3   JJ ! ! JJOO ||r,c |j|5 |j|}|j|cdddS#t$rYnwxYw|jj j |jj5|jj|i|}dddn #1swYnxYw|jj j} |j|||cdddS#ttf$rt}trCtdt|jjdtj |d|t#||jjd}~wwxYw#1swYyxYw)zHandle a cache miss: compute a new cached value, write it back to the cache, and return that newly-computed value. Nz The function zV is decorated with `st.cache_data` but it returns an unevaluated data object of type `z`. Please convert the object to a serializable format (e.g. Pandas DataFrame) before returning it, so `st.cache_data` can serialize and cache it.) return_valuerL)r8r2rrrnrScalling_cached_functionrL_most_recent_messagesr6r RuntimeErrorr rrr get_fqn_typer) r)rr1rrrcomputed_valuer5exs r*rzCachedFunc._handle_cache_misssp: % %i 0  % 1 1) < --m<1 0)   55MM "1)!K{!Kzz;;QQH ""9nhG%11 02 -  .n=4'(? (P'QR0090F0F~0V/WXFF5!/djjoo# 31 0s]E>!? A E> A  B-$ E>-B6 2'E>C88E;A/E66E;;E>>Fc|jj|j}|s|rMt|jj|jj |||jj }nd}|j|y)aClear the cached function's associated cache. If no arguments are passed, Streamlit will clear all values cached for the function. If arguments are passed, Streamlit will clear the cached value for these arguments only. Parameters ---------- *args: Any Arguments of the cached functions. **kwargs: Any Keyword arguments of the cached function. Example ------- >>> import streamlit as st >>> import time >>> >>> @st.cache_data >>> def foo(bar): >>> time.sleep(2) >>> st.write(f"Executed foo({bar}).") >>> return bar >>> >>> if st.button("Clear all cached values for `foo`", on_click=foo.clear): >>> foo.clear() >>> >>> if st.button("Clear the cached value of `foo(1)`"): >>> foo.clear(1) >>> >>> foo(1) >>> foo(2) rNr:)rnrVrurrPrLrNr<)r)rirjrr;s r*r<zCachedFunc.clear[snJ --d.@.@A 6!::00ZZ__"::00 CC  r,)r]rJr#rq)rtuple[Any, ...]rdict[str, Any]r~rCrAr)rrrAr) rr!r1r@rrrrrAr) rDrErFr+roryrkr}rrr<rHr,r*rZrZsL2O O&'+ (U"(U$(U$ (U (UTIII# I $ I IV0r,rZc <g}tt|D]$}t||}|j|||f&|j D]\}} |j|| ft j dit} |D]O\}} |(|jdrtjd|0 t|| ||t| | |||Q| j} tjd| | S#t$r} t|||| | d} ~ wwxYw)aPCreate the key for a value within a cache. This key is generated from the function's arguments. All arguments will be hashed, except for those named with a leading "_". Raises ------ StreamlitAPIException Raised (with a nicely-formatted explanation message) if we encounter an un-hashable arg. N_z'Not hashing %s because it starts with _hasherrP hash_source)rrPrNrz Cache key: %smd5)ranger|_get_positional_arg_nameappenditemshashlibnewr startswithrdebugrrr hexdigest)rPrLrrrN arg_pairsarg_idxarg_namekw_namekw_val args_hasher arg_valueexcr1s r*rrs3*/1IY(+D':(Ig$678)',,. '6*+ /++6~6K()  H$7$7$< MMCX N  S "%   "%%   )2%%'I MM/9-  # S&z49cR R Ss5C>> DDDcntjdit}t|j|j f||| t j|}t|||||jS#t$r7}tjd||jj}Yd}~Zd}~wwxYw)zCreate the unique key for a function's cache. A function's key is stable across reruns of the app, and changes when the function's source code changes. rzZFailed to retrieve function's source code when building its key; falling back to bytecode.)exc_infoNr)rrrrrErFinspect getsourceOSErrorrr__code__co_coder)rPrL func_hasher source_coders r*rtrts ++6~6K  $++, ,''- KJD  "" ,  (  mm++ ,sA44 B4=-B//B4c>|dkryttj|jj }|t |k\ry||j tjjtjjfvr||jSy)zReturn the name of a function's positional argument. If arg_index is out of range, or refers to a parameter that is not a named positional argument (e.g. an *args, **kwargs, or keyword-only param), return None instead. rN) listr signature parametersvaluesr|kind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYr)rL arg_indexparamss r*rrs1}&*7+<+rsH" #66?.' I*">H%%4"4"n""< <&&2MM`@@ @@ @ % @  @F$#Nr,