streamlit 1.45.1__py3-none-any.whl → 1.46.1__py3-none-any.whl

streamlit/runtime/caching/cache_resource_api.py

@@ -69,7 +69,7 @@ def _equal_validate_funcs(a: ValidateFunc | None, b: ValidateFunc | None) -> boo
 class ResourceCaches(CacheStatsProvider):
     """Manages all ResourceCache instances."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._caches_lock = threading.Lock()
         self._function_caches: dict[str, ResourceCache] = {}
 
@@ -151,7 +151,7 @@ class CachedResourceFuncInfo(CachedFuncInfo):
         ttl: float | timedelta | str | None,
         validate: ValidateFunc | None,
         hash_funcs: HashFuncsDict | None = None,
-    ):
+    ) -> None:
         super().__init__(
             func,
             show_spinner=show_spinner,
@@ -189,7 +189,7 @@ class CacheResourceAPI:
     and st.cache_resource.clear().
     """
 
-    def __init__(self, decorator_metric_name: str):
+    def __init__(self, decorator_metric_name: str) -> None:
         """Create a CacheResourceAPI instance.
 
         Parameters
@@ -234,7 +234,7 @@ class CacheResourceAPI:
         validate: ValidateFunc | None = None,
         experimental_allow_widgets: bool = False,
         hash_funcs: HashFuncsDict | None = None,
-    ):
+    ) -> F | Callable[[F], F]:
         return self._decorator(
             func,
             ttl=ttl,
@@ -255,7 +255,7 @@ class CacheResourceAPI:
         validate: ValidateFunc | None,
         experimental_allow_widgets: bool,
         hash_funcs: HashFuncsDict | None = None,
-    ):
+    ) -> F | Callable[[F], F]:
         """Decorator to cache functions that return global resources (e.g. database connections, ML models).
 
         Cached objects are shared across all users, sessions, and reruns. They
@@ -417,9 +417,9 @@ class CacheResourceAPI:
         # Support passing the params via function decorator, e.g.
         # @st.cache_resource(show_spinner=False)
         if func is None:
-            return lambda f: make_cached_func_wrapper(
+            return lambda f: make_cached_func_wrapper(  # type: ignore
                 CachedResourceFuncInfo(
-                    func=f,
+                    func=f,  # type: ignore
                     show_spinner=show_spinner,
                     max_entries=max_entries,
                     ttl=ttl,
@@ -455,7 +455,7 @@ class ResourceCache(Cache):
         ttl_seconds: float,
         validate: ValidateFunc | None,
         display_name: str,
-    ):
+    ) -> None:
         super().__init__()
         self.key = key
         self.display_name = display_name

streamlit/runtime/caching/cache_utils.py

@@ -65,7 +65,7 @@ TTLCACHE_TIMER = time.monotonic
 class Cache:
     """Function cache interface. Caches persist across script runs."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._value_locks: dict[str, threading.Lock] = defaultdict(threading.Lock)
         self._value_locks_lock = threading.Lock()
 
@@ -100,7 +100,7 @@ class Cache:
         with self._value_locks_lock:
             return self._value_locks[value_key]
 
-    def clear(self, key: str | None = None):
+    def clear(self, key: str | None = None) -> None:
         """Clear 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.
@@ -130,7 +130,7 @@ class CachedFuncInfo:
         func: FunctionType,
         show_spinner: bool | str,
         hash_funcs: HashFuncsDict | None,
-    ):
+    ) -> None:
         self.func = func
         self.show_spinner = show_spinner
         self.hash_funcs = hash_funcs
@@ -167,17 +167,17 @@ class BoundCachedFunc:
     decorated function is a class method.
     """
 
-    def __init__(self, cached_func: CachedFunc, instance: Any):
+    def __init__(self, cached_func: CachedFunc, instance: Any) -> None:
         self._cached_func = cached_func
         self._instance = instance
 
-    def __call__(self, *args, **kwargs) -> Any:
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         return self._cached_func(self._instance, *args, **kwargs)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<BoundCachedFunc: {self._cached_func._info.func} of {self._instance}>"
 
-    def clear(self, *args, **kwargs):
+    def clear(self, *args: Any, **kwargs: Any) -> None:
         if args or kwargs:
             # The instance is required as first parameter to allow
             # args to be correctly resolved to the parameter names:
@@ -189,21 +189,21 @@ class BoundCachedFunc:
 
 
 class CachedFunc:
-    def __init__(self, info: CachedFuncInfo):
+    def __init__(self, info: CachedFuncInfo) -> None:
         self._info = info
         self._function_key = _make_function_key(info.cache_type, info.func)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"<CachedFunc: {self._info.func}>"
 
-    def __get__(self, instance, owner=None):
+    def __get__(self, instance: Any, owner: Any | None = None) -> Any:
         """CachedFunc implements descriptor protocol to support cache methods."""
         if instance is None:
             return self
 
         return functools.update_wrapper(BoundCachedFunc(self, instance), self)
 
-    def __call__(self, *args, **kwargs) -> Any:
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
         """The wrapper. We'll only call our underlying function on a cache miss."""
 
         spinner_message: str | None = None
@@ -346,7 +346,7 @@ class CachedFunc:
                     return_value=computed_value, func=self._info.func
                 )
 
-    def clear(self, *args, **kwargs):
+    def clear(self, *args: Any, **kwargs: Any) -> None:
         """Clear the cached function's associated cache.
 
         If no arguments are passed, Streamlit will clear all values cached for
@@ -473,8 +473,9 @@ def _make_function_key(cache_type: CacheType, func: FunctionType) -> str:
 
     # Include the function's __module__ and __qualname__ strings in the hash.
     # This means that two identical functions in different modules
-    # will not share a hash; it also means that two identical *nested*
-    # functions in the same module will not share a hash.
+    # will not share a hash.
+    # It also means that two identical *nested* functions in the same module
+    # *will* share a hash (see https://github.com/streamlit/streamlit/issues/11157).
     update_hash(
         (func.__module__, func.__qualname__),
         hasher=func_hasher,

streamlit/runtime/caching/cached_message_replay.py

@@ -121,7 +121,7 @@ class CachedMessageReplayContext(threading.local):
     of this class across multiple threads.
     """
 
-    def __init__(self, cache_type: CacheType):
+    def __init__(self, cache_type: CacheType) -> None:
         self._cached_message_stack: list[list[MsgData]] = []
         self._seen_dg_stack: list[set[str]] = []
         self._most_recent_messages: list[MsgData] = []
@@ -132,7 +132,7 @@ class CachedMessageReplayContext(threading.local):
         return util.repr_(self)
 
     @contextlib.contextmanager
-    def calling_cached_function(self, func: FunctionType) -> Iterator[None]:
+    def calling_cached_function(self, func: FunctionType) -> Iterator[None]:  # noqa: ARG002
         """Context manager that should wrap the invocation of a cached function.
         It allows us to track any `st.foo` messages that are generated from inside the
         function for playback during cache retrieval.
@@ -169,8 +169,9 @@ class CachedMessageReplayContext(threading.local):
         executing cached functions, so they can be replayed any time the function's
         execution is skipped because they're in the cache.
         """
-        if not runtime.exists():
+        if not runtime.exists() or not in_cached_function.get():
             return
+
         if len(self._cached_message_stack) >= 1:
             id_to_save = self.select_dg_to_save(invoked_dg_id, used_dg_id)
 
@@ -200,6 +201,9 @@ class CachedMessageReplayContext(threading.local):
         used_dg_id: str,
         returned_dg_id: str,
     ) -> None:
+        if not in_cached_function.get():
+            return
+
         id_to_save = self.select_dg_to_save(invoked_dg_id, used_dg_id)
         for msgs in self._cached_message_stack:
             msgs.append(BlockMsgData(block_proto, id_to_save, returned_dg_id))
@@ -218,13 +222,15 @@ class CachedMessageReplayContext(threading.local):
         """
         if len(self._seen_dg_stack) > 0 and acting_on_id in self._seen_dg_stack[-1]:
             return acting_on_id
-        else:
-            return invoked_id
+        return invoked_id
 
-    def save_image_data(
-        self, image_data: bytes | str, mimetype: str, image_id: str
+    def save_media_data(
+        self, media_data: bytes | str, mimetype: str, media_id: str
     ) -> None:
-        self._media_data.append(MediaMsgData(image_data, mimetype, image_id))
+        if not in_cached_function.get():
+            return
+
+        self._media_data.append(MediaMsgData(media_data, mimetype, media_id))
 
 
 def replay_cached_messages(

streamlit/runtime/caching/hashing.py

@@ -34,7 +34,7 @@ import weakref
 from enum import Enum
 from re import Pattern
 from types import MappingProxyType
-from typing import Any, Callable, Final, Union, cast
+from typing import TYPE_CHECKING, Any, Callable, Final, Union, cast
 
 from typing_extensions import TypeAlias
 
@@ -44,6 +44,10 @@ from streamlit.runtime.caching.cache_errors import UnhashableTypeError
 from streamlit.runtime.caching.cache_type import CacheType
 from streamlit.runtime.uploaded_file_manager import UploadedFile
 
+if TYPE_CHECKING:
+    import numpy.typing as npt
+    from PIL.Image import Image
+
 _LOGGER: Final = logger.get_logger(__name__)
 
 # If a dataframe has more than this many rows, we consider it large and hash a sample.
@@ -66,11 +70,11 @@ _CYCLE_PLACEHOLDER: Final = (
 class UserHashError(StreamlitAPIException):
     def __init__(
         self,
-        orig_exc,
-        object_to_hash,
-        hash_func,
+        orig_exc: BaseException,
+        object_to_hash: Any,
+        hash_func: Callable[[Any], Any],
         cache_type: CacheType | None = None,
-    ):
+    ) -> None:
         self.alternate_name = type(orig_exc).__name__
         self.hash_func = hash_func
         self.cache_type = cache_type
@@ -80,30 +84,33 @@ class UserHashError(StreamlitAPIException):
         super().__init__(msg)
         self.with_traceback(orig_exc.__traceback__)
 
-    def _get_message_from_func(self, orig_exc, cached_func):
+    def _get_message_from_func(
+        self,
+        orig_exc: BaseException,
+        cached_func: Any,
+    ) -> str:
         args = self._get_error_message_args(orig_exc, cached_func)
 
         return (
-            """
-%(orig_exception_desc)s
+            f"""
+{args["orig_exception_desc"]}
 
-This error is likely due to a bug in %(hash_func_name)s, which is a
-user-defined hash function that was passed into the `%(cache_primitive)s` decorator of
-%(object_desc)s.
+This error is likely due to a bug in {args["hash_func_name"]}, which is a
+user-defined hash function that was passed into the `{args["cache_primitive"]}` decorator of
+{args["object_desc"]}.
 
-%(hash_func_name)s failed when hashing an object of type
-`%(failed_obj_type_str)s`.  If you don't know where that object is coming from,
+{args["hash_func_name"]} failed when hashing an object of type
+`{args["failed_obj_type_str"]}`.  If you don't know where that object is coming from,
 try looking at the hash chain below for an object that you do recognize, then
 pass that to `hash_funcs` instead:
 
 ```
-%(hash_stack)s
+{args["hash_stack"]}
 ```
 
 If you think this is actually a Streamlit bug, please
 [file a bug report here](https://github.com/streamlit/streamlit/issues/new/choose).
 """
-            % args
         ).strip("\n")
 
     def _get_error_message_args(
@@ -117,11 +124,10 @@ If you think this is actually a Streamlit bug, please
 
         if hash_source is None:
             object_desc = "something"
+        elif hasattr(hash_source, "__name__"):
+            object_desc = f"`{hash_source.__name__}()`"
         else:
-            if hasattr(hash_source, "__name__"):
-                object_desc = f"`{hash_source.__name__}()`"
-            else:
-                object_desc = "a function"
+            object_desc = "a function"
 
         decorator_name = ""
         if self.cache_type is CacheType.RESOURCE:
@@ -129,10 +135,11 @@ If you think this is actually a Streamlit bug, please
         elif self.cache_type is CacheType.DATA:
             decorator_name = "@st.cache_data"
 
-        if hasattr(self.hash_func, "__name__"):
-            hash_func_name = f"`{self.hash_func.__name__}()`"
-        else:
-            hash_func_name = "a function"
+        hash_func_name = (
+            f"`{self.hash_func.__name__}()`"
+            if hasattr(self.hash_func, "__name__")
+            else "a function"
+        )
 
         return {
             "orig_exception_desc": str(orig_exc),
@@ -146,7 +153,7 @@ If you think this is actually a Streamlit bug, please
 
 def update_hash(
     val: Any,
-    hasher,
+    hasher: Any,
     cache_type: CacheType,
     hash_source: Callable[..., Any] | None = None,
     hash_funcs: HashFuncsDict | None = None,
@@ -174,7 +181,7 @@ class _HashStack:
     This causes the "in" to crash since it expects a boolean.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._stack: collections.OrderedDict[int, list[Any]] = collections.OrderedDict()
         # A function that we decorate with streamlit cache
         # primitive (st.cache_data or st.cache_resource).
@@ -183,19 +190,19 @@ class _HashStack:
     def __repr__(self) -> str:
         return util.repr_(self)
 
-    def push(self, val: Any):
+    def push(self, val: Any) -> None:
         self._stack[id(val)] = val
 
-    def pop(self):
+    def pop(self) -> None:
         self._stack.popitem()
 
-    def __contains__(self, val: Any):
+    def __contains__(self, val: Any) -> bool:
         return id(val) in self._stack
 
     def pretty_print(self) -> str:
         def to_str(v: Any) -> str:
             try:
-                return f"Object of type {type_util.get_fqn_type(v)}: {str(v)}"
+                return f"Object of type {type_util.get_fqn_type(v)}: {v}"
             except Exception:
                 return "<Unable to convert item to string>"
 
@@ -205,7 +212,7 @@ class _HashStack:
 class _HashStacks:
     """Stacks of what has been hashed, with at most 1 stack per thread."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._stacks: weakref.WeakKeyDictionary[threading.Thread, _HashStack] = (
             weakref.WeakKeyDictionary()
         )
@@ -248,28 +255,20 @@ def _key(obj: Any | None) -> Any:
     if obj is None:
         return None
 
-    def is_simple(obj):
+    def is_simple(obj: Any) -> bool:
         return (
-            isinstance(obj, bytes)
-            or isinstance(obj, bytearray)
-            or isinstance(obj, str)
-            or isinstance(obj, float)
-            or isinstance(obj, int)
-            or isinstance(obj, bool)
-            or isinstance(obj, uuid.UUID)
+            isinstance(obj, (bytes, bytearray, str, float, int, bool, uuid.UUID))
             or obj is None
         )
 
     if is_simple(obj):
         return obj
 
-    if isinstance(obj, tuple):
-        if all(map(is_simple, obj)):
-            return obj
+    if isinstance(obj, tuple) and all(map(is_simple, obj)):
+        return obj
 
-    if isinstance(obj, list):
-        if all(map(is_simple, obj)):
-            return ("__l", tuple(obj))
+    if isinstance(obj, list) and all(map(is_simple, obj)):
+        return ("__l", tuple(obj))
 
     if inspect.isbuiltin(obj) or inspect.isroutine(obj) or inspect.iscode(obj):
         return id(obj)
@@ -280,7 +279,9 @@ def _key(obj: Any | None) -> Any:
 class _CacheFuncHasher:
     """A hasher that can hash objects with cycles."""
 
-    def __init__(self, cache_type: CacheType, hash_funcs: HashFuncsDict | None = None):
+    def __init__(
+        self, cache_type: CacheType, hash_funcs: HashFuncsDict | None = None
+    ) -> None:
         # Can't use types as the keys in the internal _hash_funcs because
         # we always remove user-written modules from memory when rerunning a
         # script in order to reload it and grab the latest code changes.
@@ -312,9 +313,8 @@ class _CacheFuncHasher:
         key = (tname, _key(obj))
 
         # Memoize if possible.
-        if key[1] is not NoResult:
-            if key in self._hashes:
-                return self._hashes[key]
+        if key[1] is not NoResult and key in self._hashes:
+            return self._hashes[key]
 
         # Break recursive cycles.
         if obj in hash_stacks.current:
@@ -340,7 +340,7 @@ class _CacheFuncHasher:
 
         return b
 
-    def update(self, hasher, obj: Any) -> None:
+    def update(self, hasher: Any, obj: Any) -> None:
         """Update the provided hasher with the hash of an object."""
         b = self.to_bytes(obj)
         hasher.update(b)
@@ -361,10 +361,10 @@ class _CacheFuncHasher:
             # deep, so we don't try to hash them at all.
             return self.to_bytes(id(obj))
 
-        elif isinstance(obj, bytes) or isinstance(obj, bytearray):
+        if isinstance(obj, (bytes, bytearray)):
             return obj
 
-        elif type_util.get_fqn_type(obj) in self._hash_funcs:
+        if type_util.get_fqn_type(obj) in self._hash_funcs:
             # Escape hatch for unsupported objects
             hash_func = self._hash_funcs[type_util.get_fqn_type(obj)]
             try:
@@ -375,57 +375,59 @@ class _CacheFuncHasher:
                 ) from ex
             return self.to_bytes(output)
 
-        elif isinstance(obj, str):
+        if isinstance(obj, str):
             return obj.encode()
 
-        elif isinstance(obj, float):
+        if isinstance(obj, float):
             return _float_to_bytes(obj)
 
-        elif isinstance(obj, int):
+        if isinstance(obj, int):
             return _int_to_bytes(obj)
 
-        elif isinstance(obj, uuid.UUID):
+        if isinstance(obj, uuid.UUID):
             return obj.bytes
 
-        elif isinstance(obj, datetime.datetime):
+        if isinstance(obj, datetime.datetime):
             return obj.isoformat().encode()
 
-        elif isinstance(obj, (list, tuple)):
+        if isinstance(obj, (list, tuple)):
             for item in obj:
                 self.update(h, item)
             return h.digest()
 
-        elif isinstance(obj, dict):
+        if isinstance(obj, dict):
             for item in obj.items():
                 self.update(h, item)
             return h.digest()
 
-        elif obj is None:
+        if obj is None:
             return b"0"
 
-        elif obj is True:
+        if obj is True:
             return b"1"
 
-        elif obj is False:
+        if obj is False:
             return b"0"
 
-        elif not isinstance(obj, type) and dataclasses.is_dataclass(obj):
+        if not isinstance(obj, type) and dataclasses.is_dataclass(obj):
             return self.to_bytes(dataclasses.asdict(obj))
-        elif isinstance(obj, Enum):
+        if isinstance(obj, Enum):
             return str(obj).encode()
 
-        elif type_util.is_type(obj, "pandas.core.series.Series"):
+        if type_util.is_type(obj, "pandas.core.series.Series"):
             import pandas as pd
 
-            obj = cast("pd.Series", obj)
-            self.update(h, obj.size)
-            self.update(h, obj.dtype.name)
+            series_obj: pd.Series = cast("pd.Series", obj)
+            self.update(h, series_obj.size)
+            self.update(h, series_obj.dtype.name)
 
-            if len(obj) >= _PANDAS_ROWS_LARGE:
-                obj = obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
+            if len(series_obj) >= _PANDAS_ROWS_LARGE:
+                series_obj = series_obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
 
             try:
-                self.update(h, pd.util.hash_pandas_object(obj).to_numpy().tobytes())
+                self.update(
+                    h, pd.util.hash_pandas_object(series_obj).to_numpy().tobytes()
+                )
                 return h.digest()
             except TypeError:
                 _LOGGER.warning(
@@ -435,22 +437,22 @@ class _CacheFuncHasher:
 
                 # Use pickle if pandas cannot hash the object for example if
                 # it contains unhashable objects.
-                return b"%s" % pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
+                return b"%s" % pickle.dumps(series_obj, pickle.HIGHEST_PROTOCOL)
 
         elif type_util.is_type(obj, "pandas.core.frame.DataFrame"):
             import pandas as pd
 
-            obj = cast("pd.DataFrame", obj)
-            self.update(h, obj.shape)
+            df_obj: pd.DataFrame = cast("pd.DataFrame", obj)
+            self.update(h, df_obj.shape)
 
-            if len(obj) >= _PANDAS_ROWS_LARGE:
-                obj = obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
+            if len(df_obj) >= _PANDAS_ROWS_LARGE:
+                df_obj = df_obj.sample(n=_PANDAS_SAMPLE_SIZE, random_state=0)
             try:
                 column_hash_bytes = self.to_bytes(
-                    pd.util.hash_pandas_object(obj.dtypes)
+                    pd.util.hash_pandas_object(df_obj.dtypes)
                 )
                 self.update(h, column_hash_bytes)
-                values_hash_bytes = self.to_bytes(pd.util.hash_pandas_object(obj))
+                values_hash_bytes = self.to_bytes(pd.util.hash_pandas_object(df_obj))
                 self.update(h, values_hash_bytes)
                 return h.digest()
             except TypeError:
@@ -461,7 +463,7 @@ class _CacheFuncHasher:
 
                 # Use pickle if pandas cannot hash the object for example if
                 # it contains unhashable objects.
-                return b"%s" % pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
+                return b"%s" % pickle.dumps(df_obj, pickle.HIGHEST_PROTOCOL)
 
         elif type_util.is_type(obj, "polars.series.series.Series"):
             import polars as pl  # type: ignore[import-not-found]
@@ -514,39 +516,32 @@ class _CacheFuncHasher:
                 # it contains unhashable objects.
                 return b"%s" % pickle.dumps(obj, pickle.HIGHEST_PROTOCOL)
         elif type_util.is_type(obj, "numpy.ndarray"):
-            import numpy as np
-
-            # write cast type as string to make it work with our Python 3.8 tests
-            # - can be removed once we sunset support for Python 3.8
-            obj = cast("np.ndarray[Any, Any]", obj)
-            self.update(h, obj.shape)
-            self.update(h, str(obj.dtype))
+            np_obj: npt.NDArray[Any] = cast("npt.NDArray[Any]", obj)
+            self.update(h, np_obj.shape)
+            self.update(h, str(np_obj.dtype))
 
-            if obj.size >= _NP_SIZE_LARGE:
+            if np_obj.size >= _NP_SIZE_LARGE:
                 import numpy as np
 
                 state = np.random.RandomState(0)
-                obj = state.choice(obj.flat, size=_NP_SAMPLE_SIZE)
+                np_obj = state.choice(np_obj.flat, size=_NP_SAMPLE_SIZE)
 
-            self.update(h, obj.tobytes())
+            self.update(h, np_obj.tobytes())
             return h.digest()
         elif type_util.is_type(obj, "PIL.Image.Image"):
             import numpy as np
-            from PIL.Image import Image  # noqa: TC002
 
-            obj = cast("Image", obj)
+            pil_obj: Image = cast("Image", obj)
 
             # we don't just hash the results of obj.tobytes() because we want to use
             # the sampling logic for numpy data
-            np_array = np.frombuffer(obj.tobytes(), dtype="uint8")
+            np_array = np.frombuffer(pil_obj.tobytes(), dtype="uint8")
             return self.to_bytes(np_array)
 
         elif inspect.isbuiltin(obj):
             return bytes(obj.__name__.encode())
 
-        elif isinstance(obj, MappingProxyType) or isinstance(
-            obj, collections.abc.ItemsView
-        ):
+        elif isinstance(obj, (MappingProxyType, collections.abc.ItemsView)):
             return self.to_bytes(dict(obj))
 
         elif type_util.is_type(obj, "builtins.getset_descriptor"):
@@ -562,9 +557,8 @@ class _CacheFuncHasher:
             return h.digest()
 
         elif hasattr(obj, "name") and (
-            isinstance(obj, io.IOBase)
             # Handle temporary files used during testing
-            or isinstance(obj, tempfile._TemporaryFileWrapper)
+            isinstance(obj, (io.IOBase, tempfile._TemporaryFileWrapper))
         ):
             # Hash files as name + last modification date + offset.
             # NB: we're using hasattr("name") to differentiate between
@@ -580,7 +574,7 @@ class _CacheFuncHasher:
         elif isinstance(obj, Pattern):
             return self.to_bytes([obj.pattern, obj.flags])
 
-        elif isinstance(obj, io.StringIO) or isinstance(obj, io.BytesIO):
+        elif isinstance(obj, (io.StringIO, io.BytesIO)):
             # Hash in-memory StringIO/BytesIO by their full contents
             # and seek position.
             self.update(h, obj.tell())

streamlit/runtime/caching/legacy_cache_api.py

@@ -36,11 +36,11 @@ def cache(
     persist: bool = False,
     allow_output_mutation: bool = False,
     show_spinner: bool = True,
-    suppress_st_warning: bool = False,
+    suppress_st_warning: bool = False,  # noqa: ARG001
     hash_funcs: HashFuncsDict | None = None,
     max_entries: int | None = None,
     ttl: float | None = None,
-):
+) -> F:
     """Legacy caching decorator (deprecated).
 
     Legacy caching with ``st.cache`` has been removed from Streamlit. This is

streamlit/runtime/caching/storage/cache_storage_protocol.py

@@ -68,7 +68,7 @@ class CacheStorageKeyNotFoundError(CacheStorageError):
     """Raised when the key is not found in the cache storage."""
 
 
-class InvalidCacheStorageContext(CacheStorageError):
+class InvalidCacheStorageContextError(CacheStorageError):
     """Raised if the cache storage manager is not able to work with
     provided CacheStorageContext.
     """

streamlit/runtime/caching/storage/dummy_cache_storage.py

@@ -40,7 +40,7 @@ class MemoryCacheStorageManager(CacheStorageManager):
 
 
 class DummyCacheStorage(CacheStorage):
-    def get(self, key: str) -> bytes:
+    def get(self, key: str) -> bytes:  # noqa: ARG002
         """
         Dummy gets the value for a given key,
         always raises an CacheStorageKeyNotFoundError.