gKUdZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z ddlmZddlmZddlZddlmZddlmZdd lmZdd lmZdd lmZmZmZdd l m!Z!m"Z"m#Z#m$Z$dd l%m&Z&ddl'm(Z(m)Z)m*Z*ddl+m,Z,er ddl-m.Z.ddl/m0Z0ee1Z2de3d<e!ejhZ5e ege6fZ7de3d<d dZ8Gdde)Z9e9Z:d!dZ;GddeZ<GddZ=GddeZ>y)"z!@st.cache_resource implementation) annotationsN) TYPE_CHECKINGAnyCallableFinalTypeVarcastoverload)TTLCache) TypeAlias) get_logger) cache_utils)CacheKeyNotFoundError) CacheType)CacheCachedFuncInfomake_cached_func_wrapper)CachedMessageReplayContext CachedResultMsgDatashow_widget_replay_deprecation)gather_metrics) CacheStatCacheStatsProvider group_stats)time_to_seconds) timedelta) HashFuncsDictr_LOGGERr ValidateFuncc.|duxr|duxs |duxr|duS)zTrue if the two validate functions are equal for the purposes of determining whether a given function cache needs to be recreated. N)abs a/var/www/openai/venv/lib/python3.12/site-packages/streamlit/runtime/caching/cache_resource_api.py_equal_validate_funcsr&<s) I #!t) I$)H1D=IcFeZdZdZdZ ddZddZd dZy) ResourceCachesz#Manages all ResourceCache instancescDtj|_i|_yN) threadingLock _caches_lock_function_cachesselfs r%__init__zResourceCaches.__init__Hs%NN,:<r'c|tj}t|}|j5|jj |}|?|j |k(r0|j|k(r!t|j|r |cdddStjd|t|||||}||j|<|cdddS#1swYyxYw)zvReturn the mem cache for the given key. If it doesn't exist, create a new one with the given params. Nz#Creating new ResourceCache (key=%s))key display_name max_entries ttl_secondsvalidate) mathinfrr.r/getr7r6r&r8rdebug ResourceCache)r1r4r5r6ttlr8r7caches r% get_cachezResourceCaches.get_cacheLs  ((K%c*   ))--c2E!%%4%%4)%..(C  MM? E!)''! E*/D ! !# &)  sAC6CCcT|j5i|_dddy#1swYyxYw)zClear all resource caches.N)r.r/r0s r% clear_allzResourceCaches.clear_allus   $&D !  s'c|j5|jj}dddg}jD]!}|j |j #t |S#1swYJxYwr+)r.r/copyvaluesextend get_statsr)r1function_cachesstatsr?s r%rGzResourceCaches.get_statszsg   #3388:O "$$++-E LL* +.5!! s A11A:N) r4strr5rJr6zint | float | Noner>float | timedelta | str | Noner8ValidateFunc | Nonereturnr=rMNonerMzlist[CacheStat])__name__ __module__ __qualname____doc__r2r@rBrGr"r'r%r)r)EsT-=' ''( ' , ' & ' 'R' "r'r)ctS)z>Return the StatsProvider for all @st.cache_resource functions.)_resource_cachesr"r'r%!get_resource_cache_stats_providerrWs r'c|eZdZdZ d dfd Zed dZed dZed dZd dZ xZ S) CachedResourceFuncInfoz>Implements the CachedFuncInfo interface for @st.cache_resourcecTt||||||_||_||_y)N) show_spinner hash_funcs)superr2r6r>r8)r1funcr[r6r>r8r\ __class__s r%r2zCachedResourceFuncInfo.__init__s8  %!  '  r'c"tjSr+)rRESOURCEr0s r% cache_typez!CachedResourceFuncInfo.cache_types!!!r'ctSr+)!CACHE_RESOURCE_MESSAGE_REPLAY_CTXr0s r%cached_message_replay_ctxz0CachedResourceFuncInfo.cached_message_replay_ctxs00r'c`|jjd|jjS)z-A human-readable name for the cached function.)r^rRrSr0s r%r5z#CachedResourceFuncInfo.display_names+))&&'q)?)?(@AAr'ctj||j|j|j|j S)N)r4r5r6r>r8)rVr@r5r6r>r8)r1 function_keys r%get_function_cachez)CachedResourceFuncInfo.get_function_caches=))**((]] *  r'r+) r^ztypes.FunctionTyper[ bool | strr6 int | Noner>rKr8rLr\HashFuncsDict | None)rMr)rMr)rMrJ)rirJrMr) rQrRrSrTr2propertyrbrer5rj __classcell__r_s@r%rYrYsH,0! !!! ! , ! & !)!$""11BB r'rYceZdZdZddZededefZe ddZ e ddddd dd  dd Z dddddd dd  dd Z dd  ddZ e dddZ y)CacheResourceAPIzvImplements the public st.cache_resource API: the @st.cache_resource decorator, and st.cache_resource.clear(). c:t||j|_y)zCreate a CacheResourceAPI instance. Parameters ---------- decorator_metric_name The metric name to record for decorator usage. N)r _decorator)r1decorator_metric_names r%r2zCacheResourceAPI.__init__s))>Pr'F.)boundcyr+r")r1r^s r%__call__zCacheResourceAPI.__call__s&)r'NTFr>r6r[r8experimental_allow_widgetsr\cyr+r")r1r>r6r[r8r{r\s r%ryzCacheResourceAPI.__call__sr'c 2|j|||||||S)Nrz)rtr1r^r>r6r[r8r{r\s r%ryzCacheResourceAPI.__call__s/ #%'A!  r')r\c |r td| fdSttttj |S)a1Decorator to cache functions that return global resources (e.g. database connections, ML models). Cached objects are shared across all users, sessions, and reruns. They must be thread-safe because they can be accessed from multiple threads concurrently. If thread safety is an issue, consider using ``st.session_state`` to store resources per session instead. You can clear a function's cache with ``func.clear()`` or clear the entire cache with ``st.cache_resource.clear()``. A function's arguments must be hashable to cache it. If you have an unhashable argument (like a database connection) or an argument you want to exclude from caching, use an underscore prefix in the argument name. In this case, Streamlit will return a cached value when all other arguments match a previous function call. Alternatively, you can declare custom hashing functions with ``hash_funcs``. To cache data, use ``st.cache_data`` instead. Learn more about caching at https://docs.streamlit.io/develop/concepts/architecture/caching. Parameters ---------- func : callable The function that creates the cached resource. Streamlit hashes the function's source code. ttl : float, timedelta, str, or None The maximum time to keep an entry in the cache. Can be one of: - ``None`` if cache entries should never expire (default). - A number specifying the time in seconds. - A string specifying the time in a format supported by `Pandas's Timedelta constructor `_, e.g. ``"1d"``, ``"1.5 days"``, or ``"1h23s"``. - A ``timedelta`` object from `Python's built-in datetime library `_, e.g. ``timedelta(days=1)``. max_entries : int or None The maximum number of entries to keep in the cache, or None for an unbounded cache. When a new entry is added to a full cache, the oldest cached entry will be removed. Defaults to None. show_spinner : bool or str Enable the spinner. Default is True to show a spinner when there is a "cache miss" and the cached resource is being created. If string, value of show_spinner param will be used for spinner text. validate : callable or None An optional validation function for cached data. ``validate`` is called each time the cached value is accessed. It receives the cached value as its only parameter and it must return a boolean. If ``validate`` returns False, the current cached value is discarded, and the decorated function is called to compute a new value. This is useful e.g. to check the health of database connections. experimental_allow_widgets : bool Allow widgets to be used in the cached function. Defaults to False. hash_funcs : dict or None Mapping of types or fully qualified names to hash functions. This is used to override the behavior of the hasher inside Streamlit's caching mechanism: when the hasher encounters an object, it will first check to see if its type matches a key in this dict and, if so, will use the provided function to generate a hash for it. See below for an example of how this can be used. .. deprecated:: The cached widget replay functionality was removed in 1.38. Please remove the ``experimental_allow_widgets`` parameter from your caching decorators. This parameter will be removed in a future version. Example ------- >>> import streamlit as st >>> >>> @st.cache_resource ... def get_database_session(url): ... # Create a database session object that points to the URL. ... return session >>> >>> s1 = get_database_session(SESSION_URL_1) >>> # Actually executes the function, since this is the first time it was >>> # encountered. >>> >>> s2 = get_database_session(SESSION_URL_1) >>> # Does not execute the function. Instead, returns its previously computed >>> # value. This means that now the connection object in s1 is the same as in s2. >>> >>> s3 = get_database_session(SESSION_URL_2) >>> # This is a different URL, so the function executes. By default, all parameters to a cache_resource function must be hashable. Any parameter whose name begins with ``_`` will not be hashed. You can use this as an "escape hatch" for parameters that are not hashable: >>> import streamlit as st >>> >>> @st.cache_resource ... def get_database_session(_sessionmaker, url): ... # Create a database connection object that points to the URL. ... return connection >>> >>> s1 = get_database_session(create_sessionmaker(), DATA_URL_1) >>> # Actually executes the function, since this is the first time it was >>> # encountered. >>> >>> s2 = get_database_session(create_sessionmaker(), DATA_URL_1) >>> # Does not execute the function. Instead, returns its previously computed >>> # value - even though the _sessionmaker parameter was different >>> # in both calls. A cache_resource function's cache can be procedurally cleared: >>> import streamlit as st >>> >>> @st.cache_resource ... def get_database_session(_sessionmaker, url): ... # Create a database connection object that points to the URL. ... return connection >>> >>> fetch_and_clean_data.clear(_sessionmaker, "https://streamlit.io/") >>> # Clear the cached entry for the arguments provided. >>> >>> get_database_session.clear() >>> # Clear all cached entries for this function. To override the default hashing behavior, pass a custom hash function. You can do that by mapping a type (e.g. ``Person``) to a hash function (``str``) like this: >>> import streamlit as st >>> from pydantic import BaseModel >>> >>> class Person(BaseModel): ... name: str >>> >>> @st.cache_resource(hash_funcs={Person: str}) ... def get_person_name(person: Person): ... return person.name Alternatively, you can map the type's fully-qualified name (e.g. ``"__main__.Person"``) to the hash function instead: >>> import streamlit as st >>> from pydantic import BaseModel >>> >>> class Person(BaseModel): ... name: str >>> >>> @st.cache_resource(hash_funcs={"__main__.Person": str}) ... def get_person_name(person: Person): ... return person.name cache_resourcec 8tt|S)Nr^r[r6r>r8r\)rrY)fr\r6r[r>r8s r%z-CacheResourceAPI._decorator..s%5&!- +%)  r'r)rrrYr types FunctionTyper~s ```` `r%rtzCacheResourceAPI._decoratorsYL & *+; < <  ( "%,,d3)'!%    r'clear_resource_cachesc,tjy)z Clear all cache_resource caches.N)rVrBr0s r%clearzCacheResourceAPI.clears ""$r')rurJ)r^rvrMrv)r>rKr6rlr[rkr8rLr{boolr\rmrMzCallable[[F], F]r+)r^zF | Noner>rKr6rlr[rkr8rLr{rr\rmrN)rQrRrSrTr2rrrrvr ryrtrrr"r'r%rrrrsz Q 8CH-.A))/3"&#'(,+0+/ ,   !  & %) )     /3"&#'(,+0+/  ,    !  & %) ) <,0@ @ , @  @ ! @ &@ %)@ )@ D+,%-%r'rrceZdZdZ d fd Zed dZed dZd dZe dd dZ dddZ dd Z xZ S)r=z>Manages cached values for a single st.cache_resource function.ct|||_||_t ||t j |_tj|_ ||_ y)N)maxsizer>timer) r]r2r4r5r rTTLCACHE_TIMER _mem_cacher,r-_mem_cache_lockr8)r1r4r6r7r8r5r_s r%r2zResourceCache.__init__sP (7?[ 8R8R8  )~~/  r'c.|jjSr+)rrr0s r%r6zResourceCache.max_entriess&&&r'c.|jjSr+)rr>r0s r%r7zResourceCache.ttl_secondss"""r'c|j5||jvr t|j|}|j2|j|js|j|=t|cdddS#1swYyxYw)zRead a value and associated messages from the cache. Raise `CacheKeyNotFoundError` if the value doesn't exist. N)rrrr8value)r1r4results r% read_resultzResourceCache.read_resultsm ! !$//)+--__S)F}}(v||1LOOC(+--" ! !s A'A>>B_cache_resource_objectctjj}tjj}|j5t |||||j |<dddy#1swYyxYw)z3Write a value and associated messages to the cache.N)st_mainidsidebarrrr)r1r4rmessagesmain_id sidebar_ids r% write_resultzResourceCache.write_resultsL((++ZZ]]  ! !#/x*#UDOOC " ! !s A&&A/c|j5||jjn||jvr |j|=dddy#1swYyxYwr+)rrr)r1r4s r%_clearzResourceCache._clearsD  ! !{%%''OOC( " ! !s 9AAc |j5t|jj}dddddlm}Dcgc] }t d|j||"c}S#1swY;xYwcc}w)Nr)asizeofst_cache_resource) category_name cache_name byte_length)rlistrrE streamlit.vendor.pympler.asizeofrrr5)r1 cache_entriesrentrys r%rGzResourceCache.get_statssy ! ! !7!7!9:M" ='  ' 1,,#EN  '   " !  s$A+%A7+A4) r4rJr6floatr7rr8rLr5rJ)rMr)r4rJrMr)r4rJrrrz list[MsgData]rMrOr+)r4z str | NonerMrOrP)rQrRrSrTr2rnr6r7rrrrrGrorps@r%r=r=sH! !! ! & !  !"''##$,-V.V) r'r=)r#rLr$rLrMr)rMr)?rT __future__rr9r,rtypingrrrrrr r cachetoolsr typing_extensionsr streamlitrstreamlit.loggerr streamlit.runtime.cachingr&streamlit.runtime.caching.cache_errorsr$streamlit.runtime.caching.cache_typer%streamlit.runtime.caching.cache_utilsrrr/streamlit.runtime.caching.cached_message_replayrrrrstreamlit.runtime.metrics_utilrstreamlit.runtime.statsrrrstreamlit.time_utilrdatetimer!streamlit.runtime.caching.hashingrrQr__annotations__rardrr r&r)rVrWrYrrr=r"r'r%rs("  OOO''1H:  :NN/"?H%%%?y?Q?Q$R!"C5$;/ i/J>"'>"D"# ) ^) XB%B%JO EO r'