mxidZddlmZddlmZddlmZmZmZddl m Z ddl m Z ddl mZerddlmZed ed ef Zed  d ddZy )zA library of caching utilities.) annotations)Callable) TYPE_CHECKINGAnyTypeVar)deprecation_util)CACHE_DOCS_URL)gather_metrics) HashFuncsDictF.)boundcacheNcddl}tjdtd|r|j |||||S|j ||||||S)a Legacy caching decorator (deprecated). Legacy caching with ``st.cache`` has been removed from Streamlit. This is now an alias for ``st.cache_data`` and ``st.cache_resource``. Parameters ---------- func : callable The function to cache. Streamlit hashes the function's source code. persist : bool Whether to persist the cache on disk. allow_output_mutation : bool Whether to use ``st.cache_data`` or ``st.cache_resource``. If this is ``False`` (default), the arguments are passed to ``st.cache_data``. If this is ``True``, the arguments are passed to ``st.cache_resource``. show_spinner : bool Enable the spinner. Default is ``True`` to show a spinner when there is a "cache miss" and the cached data is being created. suppress_st_warning : bool This is not used. 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. 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.) The default is ``None``. ttl : float or None The maximum number of seconds to keep an entry in the cache, or None if cache entries should not expire. The default is None. Example ------- >>> import streamlit as st >>> >>> @st.cache ... def fetch_and_clean_data(url): ... # Fetch data from URL here, and then clean it up. ... return data >>> >>> d1 = fetch_and_clean_data(DATA_URL_1) >>> # Actually executes the function, since this is the first time it was >>> # encountered. >>> >>> d2 = fetch_and_clean_data(DATA_URL_1) >>> # Does not execute the function. Instead, returns its previously computed >>> # value. This means that now the data in d1 is the same as in d2. >>> >>> d3 = fetch_and_clean_data(DATA_URL_2) >>> # This is a different URL, so the function executes. To set the ``persist`` parameter, use this command as follows: >>> @st.cache(persist=True) ... def fetch_and_clean_data(url): ... # Fetch data from URL here, and then clean it up. ... return data To disable hashing return values, set the ``allow_output_mutation`` parameter to ``True``: >>> @st.cache(allow_output_mutation=True) ... def fetch_and_clean_data(url): ... # Fetch data from URL here, and then clean it up. ... return data To override the default hashing behavior, pass a custom hash function. You can do that by mapping a type (e.g. ``MongoClient``) to a hash function (``id``) like this: >>> @st.cache(hash_funcs={MongoClient: id}) ... def connect_to_database(url): ... return MongoClient(url) Alternatively, you can map the type's fully-qualified name (e.g. ``"pymongo.mongo_client.MongoClient"``) to the hash function instead: >>> @st.cache(hash_funcs={"pymongo.mongo_client.MongoClient": id}) ... def connect_to_database(url): ... return MongoClient(url) rNz `st.cache` is deprecated and will be removed soon. Please use one of Streamlit's new caching commands, `st.cache_data` or `st.cache_resource`. More information [in our docs](z). **Note**: The behavior of `st.cache` was updated in Streamlit 1.36 to the new caching logic used by `st.cache_data` and `st.cache_resource`. This might lead to some problems or unexpected behavior in certain edge cases. ) show_spinner hash_funcs max_entriesttl)persistrrrr) streamlitrshow_deprecation_warningr cache_resource cache_data) funcrallow_output_mutationrsuppress_st_warningrrrsts a/home/htdocs/ttos/venv/lib/python3.12/site-packages/streamlit/runtime/caching/legacy_cache_api.pyrr"sP--     %!# !   == !   )NFFTFNNN)rzF | NonerboolrrrrrrrzHashFuncsDict | Nonerz int | Nonerz float | Nonereturnr )__doc__ __future__rcollections.abcrtypingrrrrrstreamlit.runtime.cachingr streamlit.runtime.metrics_utilr !streamlit.runtime.caching.hashingr r rrrr)s&"$..&49? CxS)*"' %'+"G G G G G  G % GG GGGr