&eEdZddlmZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl m Z ddlmZddlmZmZmZddlmZdd lmZdd lmZdd lmZdd lmZmZmZm Z m!Z!m"Z"m#Z#m$Z$dd l%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+ddl,m-Z-m.Z.ddl/m0Z0ee1Z2ej3Z4ed9dZ5ed:dZ5ddd;dZ5dZ6Gdd Z7Gd!d"Z8dd4Z7R7R!*!1!1r) value_keyr2r"rct)zRead a value and associated messages from the cache. Raises ------ CacheKeyNotFoundError Raised if value_key is not in the cache. NotImplementedErrorrDrFs r' read_resultzCache.read_resultvs "!r)valuermessages list[MsgData]Nonect)z}Write a value and associated messages to the cache, overwriting any existing result that uses the value_key. rH)rDrFrLrMs r' write_resultzCache.write_results "!r)threading.Lockc^|j5|j|cdddS#1swxYwYdS)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)rBrArJs r'compute_value_lockzCache.compute_value_locks| # 0 0$Y/ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0s "&&c|j5|jdddn #1swxYwY|dS)z!Clear all values from this cache.N)rBrAclear_clearrCs r'rVz Cache.clears  # & &   # # % % % & & & & & & & & & & & & & & & s .22ct)z?Subclasses must implement this to perform cache-clearing logic.rHrCs r'rWz Cache._clears "!r)N)rFr2r"r)rFr2rLrrMrNr"rO)rFr2r"rR)r"rO) __name__ __module__ __qualname____doc__rErrKrQrTrVrWr&r)r'r=r=osFF222 " " "^ """"^"0000 """^"""r)r=cReZdZdZdd Zedd ZeddZddZdS)CachedFuncInfozEncapsulates data for a cached function instance. CachedFuncInfo instances are scoped to a single script run - they're not persistent. functypes.FunctionType show_spinner bool | str allow_widgetsr, hash_funcsHashFuncsDict | Nonec>||_||_||_||_dSr%)r_rarcrd)rDr_rarcrds r'rEzCachedFuncInfo.__init__s& (*$r)r"rctr%rHrCs r' cache_typezCachedFuncInfo.cache_type!!r)rctr%rHrCs r'cached_message_replay_ctxz(CachedFuncInfo.cached_message_replay_ctxrir) function_keyr2r=ct)z3Get or create the function cache for the given key.rH)rDrls r'get_function_cachez!CachedFuncInfo.get_function_cacherir)N)r_r`rarbrcr,rdre)r"r)r"r)rlr2r"r=) rYrZr[r\rEpropertyrhrkrnr&r)r'r^r^s % % % %"""X""""X"""""""r)r^infoCallable[..., Any]ct|tj|jfd}j|_|S)aYCreate 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 all of the wrapper's cached values. c|i|Sr%r&)argskwargs cached_funcs r'wrapperz)make_cached_func_wrapper..wrappers{D+F+++r)) CachedFunc functoolswrapsr_rV)rprwrvs @r'make_cached_func_wrapperr{sUT""K_TY,,,, ,  %GM Nr)c<eZdZddZddZdd ZddZddZdZdS)rxrpr^cR||_t|j|j|_dSr%)_info_make_function_keyrhr_ _function_key)rDrps r'rEzCachedFunc.__init__s% /KKr)r"rc|jjj}t|jjt r4t |dkrt |dkrd|d}nd|d}n |jj}|jjst|jjtrAt|d5| ||cdddS#1swxYwYdS| ||S)zEThe wrapper. We'll only call our underlying function on a cache miss.rz Running `z()`.z(...)`.T)cacheN) r~r_r[r0rar,lenr2r _get_or_create_cached_value)rDrtrunamemessages r'__call__zCachedFunc.__call__sOz+ dj-t 4 4 .4yyA~~#f++"2"20d0003d333j-G : " Bj1H#&N&N B--- F F77fEE F F F F F F F F F F F F F F F F F F33D&AA As-CCC func_argstuple[Any, ...] func_kwargsdict[str, Any]cJ|j|j}t|jj|jj|||jj} ||}||S#t$r| ||||cYSwxYw)N)rhr_rrrd) r~rnr_make_value_keyrhr_rdrK_handle_cache_hitr_handle_cache_miss)rDrrrrF cached_results r'rz&CachedFunc._get_or_create_cached_values  --d.@AA$z,#z,     U!--i88M))-88 8$ U U U**5)Y TT T T T Us)A=="B"!B"resultrcZt||jj|jj|jS)zNHandle a cache hit: replay the result's cached messages, and return its value.)rr~rhr_rL)rDrs r'rzCachedFunc._handle_cache_hit s0  J ! JO   |r)rr=rFr2c  ||5 ||}||cdddS#t$r|jj|jj|jj5|jj|i|dddn #1swxYwY|jjj } | ||cYcdddS#ttf$rpdfdtDvr?tdt|jjdt!jdt%|jjwxYwwxYw#1swxYwYdS)zHandle a cache miss: compute a new cached value, write it back to the cache, and return that newly-computed value. NTc:g|]}tj|Sr&)r is_type).0 type_namecomputed_values r' z1CachedFunc._handle_cache_miss..Ms6   %").)DD   r)z* The function zp is decorated with `st.cache_data` but it returns an unevaluated dataframe of type `z`. Please call `collect()` or `to_pandas()` on the dataframe before returning it, so `st.cache_data` can serialize and cache it.) return_valuer_)rTrKrrr~rkcalling_cached_functionr_rc_most_recent_messagesrQr RuntimeErrorUNEVALUATED_DATAFRAME_TYPESrrr get_fqn_typer)rDrrFrrrrMrs @r'rzCachedFunc._handle_cache_misss: % %i 0 0& & "  % 1 1) < < --m<<& & & & & & & & )   Z9QQJOTZ%=PP&5TZ_i%O;%O%ONPPPPPPPPPPPPPPP :?U&&y.(KKK)))+& & & & & & & & ,#L1    )D   8N*A$*/*R*RNN&/&<^&L&LNNN 9%3$*/ & & & & & & & & & & seE9)A?E6B-! E6-B1 1E64B1 5E6 C1"E6#E91BE22E66E99E=E=cl|j|j}|dS)z.Clear the wrapped function's associated cache.N)r~rnrrV)rDrs r'rVzCachedFunc.clear[s+ --d.@AA r)N)rpr^)r"r)rrrrr"r)rrr"r) rr=rFr2rrrrr"r) rYrZr[rErrrrrVr&r)r'rxrxsLLLLBBBB&UUUU0CCCCJr)rxrhrr_r`rrrrrdrer2c g}tt|D]/}t||}||||f0|D]\}} ||| ft jdit} |D]\}} |1|drt d|8 t|| ||t| | |||a#t$r} t|||| | d} ~ wwxYw| } t d| | S) 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. md5N_z'Not hashing %s because it starts with _hasherrh hash_source)rrhrdrz Cache key: %sr)ranger_get_positional_arg_nameappenditemshashlibnewr startswith_LOGGERdebugrrr hexdigest)rhr_rrrd arg_pairsarg_idxarg_namekw_namekw_val args_hasher arg_valueexcrFs r'rras*/1IY((99+D'::(Ig$678888&,,..,, '6*++++ +66~66K(SS)  H$7$7$<$<  MMCX N N N  S "%      "%%      # S S S&z49cRR R S%%''I MM/9--- s'C99 DDDcftjdit}t|j|jf||| t j|}n>#t$r1}t d||j j }Yd}~nd}~wwxYwt||||| }|S)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. rrzbFailed to retrieve function's source code when building its key; falling back to bytecode. err={0}Nr)rrrrrZr[inspect getsourceOSErrorrr__code__co_coder)rhr_ func_hasher source_codee cache_keys r'rrs +66~66K  $+, ,'-- ,,, p    m+ ,KJD%%''I sA B'BB arg_indexint str | Nonec(|dkrdSttj|j}|t |krdS||jtjjtjj fvr ||j SdS)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 parametersvaluesrkind ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYr)r_rparamss r'rrs1}}t&*7+r\ __future__rryrrr.r?timetypesabcr collectionsrdatetimertypingrrr typing_extensionsr streamlitr streamlit.elements.spinnerr streamlit.loggerr &streamlit.runtime.caching.cache_errorsrrrrrrrr$streamlit.runtime.caching.cache_typer/streamlit.runtime.caching.cached_message_replayrrrr!streamlit.runtime.caching.hashingrrstreamlit.utilrrYr monotonicTTLCACHE_TIMERr(rr=r^r{rxrrrr&r)r'rsJHG""""""  ######**********%%%%%%......''''''                    ;::::: IHHHHHHH)))))) *X        HL:/"/"/"/"/"/"/"/"d""""""""@8AAAAAAAAH@@@@F$$$$Nr)