o hK@sUdZddlmZddlZddlZddlmZmZmZm Z m Z m Z m Z ddl mZddlmZddlZddlmZddlmZdd lmZdd lmZdd lmZmZmZdd lm Z m!Z!m"Z"m#Z#dd l$m%Z%ddl&m'Z'm(Z(m)Z)ddl*m+Z+erddl,Z,ddl-m.Z.ddl/m0Z0ee1Z2de3d<e ej4Z5eege6fZ7de3d<d(ddZ8Gddde(Z9e9Z:d)d d!Z;Gd"d#d#eZdS)*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 ValidateFuncaValidateFunc | NonebreturnboolcCs |dur|dup|duo|duS)zTrue if the two validate functions are equal for the purposes of determining whether a given function cache needs to be recreated. N)r r"r%r%`/var/www/vscode/kcb/lib/python3.10/site-packages/streamlit/runtime/caching/cache_resource_api.py_equal_validate_funcs<s r'c@s6eZdZdZddZdddZdddZdddZdS)ResourceCachesz$Manages all ResourceCache instances.cCst|_i|_dSN) threadingLock _caches_lock_function_cachesselfr%r%r&__init__Hs  zResourceCaches.__init__keystr display_name max_entriesint | float | Nonettlfloat | timedelta | str | Nonevalidater!r# ResourceCachecCs|durtj}t|}|jA|j|}|dur2|j|kr2|j|kr2t|j |r2|WdSt d|t |||||d}||j|<|WdS1sRwYdS)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))r1r3r4 ttl_secondsr8) mathinfrr,r-getr:r4r'r8rdebugr9)r/r1r3r4r6r8r:cacher%r%r& get_cacheLs.       $zResourceCaches.get_cacheNonecCs2|j i|_WddS1swYdS)zClear all resource caches.N)r,r-r.r%r%r& clear_allus"zResourceCaches.clear_alllist[CacheStat]cCsX|j |j}Wdn1swYg}|D] }||qt|Sr))r,r-copyvaluesextend get_statsr)r/function_cachesstatsr?r%r%r&rGzs  zResourceCaches.get_statsN) r1r2r3r2r4r5r6r7r8r!r#r9r#rAr#rC)__name__ __module__ __qualname____doc__r0r@rBrGr%r%r%r&r(Es   )r(rcCtS)z>Return the StatsProvider for all @st.cache_resource functions.)_resource_cachesr%r%r%r&!get_resource_cache_stats_providerrRcsZeZdZdZ dd fdd Zed!ddZed"ddZed#ddZd$ddZ Z S)%CachedResourceFuncInfoz?Implements the CachedFuncInfo interface for @st.cache_resource.Nfunctypes.FunctionType show_spinner bool | strr4 int | Noner6r7r8r! hash_funcsHashFuncsDict | Nonecs(tj|||d||_||_||_dS)N)rWrZ)superr0r4r6r8)r/rUrWr4r6r8rZ __class__r%r&r0s  zCachedResourceFuncInfo.__init__r#rcCstjSr))rRESOURCEr.r%r%r& cache_typesz!CachedResourceFuncInfo.cache_typercCrPr))!CACHE_RESOURCE_MESSAGE_REPLAY_CTXr.r%r%r&cached_message_replay_ctxrSz0CachedResourceFuncInfo.cached_message_replay_ctxr2cCs|jjd|jjS)z.A human-readable name for the cached function..)rUrMrNr.r%r%r&r3sz#CachedResourceFuncInfo.display_name function_keyrcCstj||j|j|j|jdS)N)r1r3r4r6r8)rQr@r3r4r6r8)r/rdr%r%r&get_function_cachesz)CachedResourceFuncInfo.get_function_cacher)) rUrVrWrXr4rYr6r7r8r!rZr[)r#r)r#r)r#r2)rdr2r#r) rLrMrNrOr0propertyr`rbr3re __classcell__r%r%r]r&rTs    rTc@seZdZdZd(ddZededefdZe d)d d Z e d d dd dd dd*dd Z d+d d dd dd dd,d d Z d d!d,d"d#Z e d$d-d&d'Z d S).CacheResourceAPIzvImplements the public st.cache_resource API: the @st.cache_resource decorator, and st.cache_resource.clear(). decorator_metric_namer2cCst||j|_dS)zCreate a CacheResourceAPI instance. Parameters ---------- decorator_metric_name The metric name to record for decorator usage. N)r _decorator)r/rir%r%r&r0s zCacheResourceAPI.__init__F.)boundrUr#cCdSr)r%)r/rUr%r%r&__call__szCacheResourceAPI.__call__NTFr6r4rWr8experimental_allow_widgetsrZr6r7r4rYrWrXr8r!rpr$rZr[Callable[[F], F]cCrmr)r%)r/r6r4rWr8rprZr%r%r&rns F | Nonec Cs|j|||||||dS)Nro)rjr/rUr6r4rWr8rprZr%r%r&rns )rZc sF|rtd|durfddStttd|dS)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_resourceNc stt|dS)NrUrWr4r6r8rZ)rrT)frZr4rWr6r8r%r&sz-CacheResourceAPI._decorator..rVru)rrrTrrsr%rwr&rjs' zCacheResourceAPI._decoratorclear_resource_cachesrAcCs tdS)z Clear all cache_resource caches.N)rQrBr.r%r%r&clears zCacheResourceAPI.clear)rir2)rUrkr#rk)r6r7r4rYrWrXr8r!rpr$rZr[r#rqr))rUrrr6r7r4rYrWrXr8r!rpr$rZr[rJ)rLrMrNrOr0rrrrkr rnrjrrzr%r%r%r&rhs8   CrhcspeZdZdZd#fd d Zed$d dZed$ddZd%ddZe dd&ddZ d'd(ddZ d)d!d"Z Z S)*r9z>Manages cached values for a single st.cache_resource function.r1r2r4floatr:r8r!r3cs<t||_||_t||tjd|_t |_ ||_ dS)N)maxsizer6timer) r\r0r1r3r r TTLCACHE_TIMER _mem_cacher*r+_mem_cache_lockr8)r/r1r4r:r8r3r]r%r&r0s   zResourceCache.__init__r#cC|jjSr))rr|r.r%r%r&r4zResourceCache.max_entriescCrr))rr6r.r%r%r&r:rzResourceCache.ttl_secondsrcCsl|j)||jvr t|j|}|jdur#||js#|j|=t|WdS1s/wYdS)zRead a value and associated messages from the cache. Raise `CacheKeyNotFoundError` if the value doesn't exist. N)rrrr8value)r/r1resultr%r%r& read_results  $zResourceCache.read_result_cache_resource_objectrrmessages list[MsgData]rAcCsPtjj}tjj}|jt|||||j|<WddS1s!wYdS)z3Write a value and associated messages to the cache.N)st_mainidsidebarrrr)r/r1rrmain_id sidebar_idr%r%r& write_results "zResourceCache.write_resultN str | NonecCsr|j,|dur|jn||jvr|j|=WddSWddSWddS1s2wYdSr))rrrz)r/r1r%r%r&_clears   "zResourceCache._clearrCcsTjtj}Wdn1swYddlmfdd|DS)Nr)asizeofcs g|] }tdj|dqS)st_cache_resource) category_name cache_name byte_length)rr3).0entryrr/r%r& sz+ResourceCache.get_stats..)rlistrrE streamlit.vendor.pympler.asizeofr)r/ cache_entriesr%rr&rGs  zResourceCache.get_stats) r1r2r4r{r:r{r8r!r3r2)r#r{)r1r2r#r)r1r2rrrrr#rAr))r1rr#rArK)rLrMrNrOr0rfr4r:rrrrrGrgr%r%r]r&r9s     r9)r r!r"r!r#r$)r#r)?rO __future__rr;r*typingrrrrrrr 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_utilrtypesdatetimer!streamlit.runtime.caching.hashingrrLr__annotations__r_rar$rr'r(rQrRrTrhr9r%r%r%r&sB $             B ,