streamlit-nightly 1.31.2.dev20240213__py2.py3-none-any.whl → 1.31.2.dev20240214__py2.py3-none-any.whl

streamlit/runtime/forward_msg_queue.py

@@ -12,14 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, List, Optional, Tuple
+from __future__ import annotations
+
+from typing import Any
 
-from streamlit.logger import get_logger
 from streamlit.proto.Delta_pb2 import Delta
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 
-LOGGER = get_logger(__name__)
-
 
 class ForwardMsgQueue:
     """Accumulates a session's outgoing ForwardMsgs.
@@ -33,15 +32,15 @@ class ForwardMsgQueue:
     """
 
     def __init__(self):
-        self._queue: List[ForwardMsg] = []
+        self._queue: list[ForwardMsg] = []
         # A mapping of (delta_path -> _queue.indexof(msg)) for each
         # Delta message in the queue. We use this for coalescing
         # redundant outgoing Deltas (where a newer Delta supersedes
         # an older Delta, with the same delta_path, that's still in the
         # queue).
-        self._delta_index_map: Dict[Tuple[int, ...], int] = dict()
+        self._delta_index_map: dict[tuple[int, ...], int] = dict()
 
-    def get_debug(self) -> Dict[str, Any]:
+    def get_debug(self) -> dict[str, Any]:
         from google.protobuf.json_format import MessageToDict
 
         return {
@@ -85,7 +84,7 @@ class ForwardMsgQueue:
         self._queue = []
         self._delta_index_map = dict()
 
-    def flush(self) -> List[ForwardMsg]:
+    def flush(self) -> list[ForwardMsg]:
         """Clear the queue and return a list of the messages it contained
         before being cleared.
         """
@@ -107,7 +106,7 @@ def _is_composable_message(msg: ForwardMsg) -> bool:
     return delta_type != "add_rows" and delta_type != "arrow_add_rows"
 
 
-def _maybe_compose_deltas(old_delta: Delta, new_delta: Delta) -> Optional[Delta]:
+def _maybe_compose_deltas(old_delta: Delta, new_delta: Delta) -> Delta | None:
     """Combines new_delta onto old_delta if possible.
 
     If the combination takes place, the function returns a new Delta that

streamlit/runtime/legacy_caching/caching.py

@@ -14,6 +14,8 @@
 
 """A library of caching utilities."""
 
+from __future__ import annotations
+
 import contextlib
 import functools
 import hashlib
@@ -26,19 +28,7 @@ import threading
 import time
 from collections import namedtuple
 from dataclasses import dataclass
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Final,
-    Iterator,
-    List,
-    Optional,
-    TypeVar,
-    Union,
-    cast,
-    overload,
-)
+from typing import Any, Callable, Final, Iterator, TypeVar, cast, overload
 
 from cachetools import TTLCache
 
@@ -72,7 +62,7 @@ _DiskCacheEntry = namedtuple("_DiskCacheEntry", ["value"])
 
 # When we show the "st.cache is deprecated" warning, we make a recommendation about which new
 # cache decorator to switch to for the following data types:
-NEW_CACHE_FUNC_RECOMMENDATIONS: Dict[str, CacheType] = {
+NEW_CACHE_FUNC_RECOMMENDATIONS: dict[str, CacheType] = {
     # cache_data recommendations:
     "str": CacheType.DATA,
     "float": CacheType.DATA,
@@ -165,7 +155,7 @@ class _MemCaches(CacheStatsProvider):
     def __init__(self):
         # Contains a cache object for each st.cache'd function
         self._lock = threading.RLock()
-        self._function_caches: Dict[str, MemCache] = {}
+        self._function_caches: dict[str, MemCache] = {}
 
     def __repr__(self) -> str:
         return util.repr_(self)
@@ -173,8 +163,8 @@ class _MemCaches(CacheStatsProvider):
     def get_cache(
         self,
         key: str,
-        max_entries: Optional[float],
-        ttl: Optional[float],
+        max_entries: float | None,
+        ttl: float | None,
         display_name: str = "",
     ) -> MemCache:
         """Return the mem cache for the given key.
@@ -220,7 +210,7 @@ class _MemCaches(CacheStatsProvider):
         with self._lock:
             self._function_caches = {}
 
-    def get_stats(self) -> List[CacheStat]:
+    def get_stats(self) -> list[CacheStat]:
         with self._lock:
             # Shallow-clone our caches. We don't want to hold the global
             # lock during stats-gathering.
@@ -245,7 +235,7 @@ _mem_caches = _MemCaches()
 # and decremented when we exit.
 class ThreadLocalCacheInfo(threading.local):
     def __init__(self):
-        self.cached_func_stack: List[Callable[..., Any]] = []
+        self.cached_func_stack: list[Callable[..., Any]] = []
         self.suppress_st_function_warning = 0
 
     def __repr__(self) -> str:
@@ -275,7 +265,7 @@ def suppress_cached_st_function_warning() -> Iterator[None]:
 
 
 def _show_cached_st_function_warning(
-    dg: "st.delta_generator.DeltaGenerator",
+    dg: st.delta_generator.DeltaGenerator,
     st_func_name: str,
     cached_func: Callable[..., Any],
 ) -> None:
@@ -287,7 +277,7 @@ def _show_cached_st_function_warning(
 
 
 def maybe_show_cached_st_function_warning(
-    dg: "st.delta_generator.DeltaGenerator", st_func_name: str
+    dg: st.delta_generator.DeltaGenerator, st_func_name: str
 ) -> None:
     """If appropriate, warn about calling st.foo inside @cache.
 
@@ -317,7 +307,7 @@ def _read_from_mem_cache(
     key: str,
     allow_output_mutation: bool,
     func_or_code: Callable[..., Any],
-    hash_funcs: Optional[HashFuncsDict],
+    hash_funcs: HashFuncsDict | None,
 ) -> Any:
     cache = mem_cache.cache
     if key in cache:
@@ -347,7 +337,7 @@ def _write_to_mem_cache(
     value: Any,
     allow_output_mutation: bool,
     func_or_code: Callable[..., Any],
-    hash_funcs: Optional[HashFuncsDict],
+    hash_funcs: HashFuncsDict | None,
 ) -> None:
     if allow_output_mutation:
         hash = None
@@ -359,7 +349,7 @@ def _write_to_mem_cache(
 
 
 def _get_output_hash(
-    value: Any, func_or_code: Callable[..., Any], hash_funcs: Optional[HashFuncsDict]
+    value: Any, func_or_code: Callable[..., Any], hash_funcs: HashFuncsDict | None
 ) -> bytes:
     hasher = hashlib.new("md5", **HASHLIB_KWARGS)
     update_hash(
@@ -400,7 +390,7 @@ def _write_to_disk_cache(key: str, value: Any) -> None:
         # Clean up file so we don't leave zero byte files.
         try:
             os.remove(path)
-        except (FileNotFoundError, IOError, OSError):
+        except (FileNotFoundError, OSError):
             # If we can't remove the file, it's not a big deal.
             pass
         raise CacheError("Unable to write to cache: %s" % e)
@@ -412,7 +402,7 @@ def _read_from_cache(
     persist: bool,
     allow_output_mutation: bool,
     func_or_code: Callable[..., Any],
-    hash_funcs: Optional[HashFuncsDict] = None,
+    hash_funcs: HashFuncsDict | None = None,
 ) -> Any:
     """Read a value from the cache.
 
@@ -447,7 +437,7 @@ def _write_to_cache(
     persist: bool,
     allow_output_mutation: bool,
     func_or_code: Callable[..., Any],
-    hash_funcs: Optional[HashFuncsDict] = None,
+    hash_funcs: HashFuncsDict | None = None,
 ):
     _write_to_mem_cache(
         mem_cache, key, value, allow_output_mutation, func_or_code, hash_funcs
@@ -466,9 +456,9 @@ def cache(
     allow_output_mutation: bool = False,
     show_spinner: bool = True,
     suppress_st_warning: bool = False,
-    hash_funcs: Optional[HashFuncsDict] = None,
-    max_entries: Optional[int] = None,
-    ttl: Optional[float] = None,
+    hash_funcs: HashFuncsDict | None = None,
+    max_entries: int | None = None,
+    ttl: float | None = None,
 ) -> F:
     ...
 
@@ -480,23 +470,23 @@ def cache(
     allow_output_mutation: bool = False,
     show_spinner: bool = True,
     suppress_st_warning: bool = False,
-    hash_funcs: Optional[HashFuncsDict] = None,
-    max_entries: Optional[int] = None,
-    ttl: Optional[float] = None,
+    hash_funcs: HashFuncsDict | None = None,
+    max_entries: int | None = None,
+    ttl: float | None = None,
 ) -> Callable[[F], F]:
     ...
 
 
 def cache(
-    func: Optional[F] = None,
+    func: F | None = None,
     persist: bool = False,
     allow_output_mutation: bool = False,
     show_spinner: bool = True,
     suppress_st_warning: bool = False,
-    hash_funcs: Optional[HashFuncsDict] = None,
-    max_entries: Optional[int] = None,
-    ttl: Optional[float] = None,
-) -> Union[Callable[[F], F], F]:
+    hash_funcs: HashFuncsDict | None = None,
+    max_entries: int | None = None,
+    ttl: float | None = None,
+) -> Callable[[F], F] | F:
     """Function decorator to memoize function executions.
 
     Parameters
@@ -674,7 +664,7 @@ def cache(
 
             # Avoid recomputing the body's hash by just appending the
             # previously-computed hash to the arg hash.
-            value_key = "%s-%s" % (value_key, cache_key)
+            value_key = "{}-{}".format(value_key, cache_key)
 
             _LOGGER.debug("Cache key: %s", value_key)
 
@@ -731,7 +721,7 @@ def cache(
     return cast(F, wrapped_func)
 
 
-def _hash_func(func: Callable[..., Any], hash_funcs: Optional[HashFuncsDict]) -> str:
+def _hash_func(func: Callable[..., Any], hash_funcs: HashFuncsDict | None) -> str:
     # Create the unique key for a function's cache. The cache will be retrieved
     # from inside the wrapped function.
     #
@@ -839,7 +829,7 @@ class CachedObjectMutationError(ValueError):
 class CachedStFunctionWarning(StreamlitAPIWarning):
     def __init__(self, st_func_name, cached_func):
         msg = self._get_message(st_func_name, cached_func)
-        super(CachedStFunctionWarning, self).__init__(msg)
+        super().__init__(msg)
 
     def _get_message(self, st_func_name, cached_func):
         args = {
@@ -865,7 +855,7 @@ to suppress the warning.
 class CachedObjectMutationWarning(StreamlitAPIWarning):
     def __init__(self, orig_exc):
         msg = self._get_message(orig_exc)
-        super(CachedObjectMutationWarning, self).__init__(msg)
+        super().__init__(msg)
 
     def _get_message(self, orig_exc):
         return (

streamlit/runtime/media_file_manager.py

@@ -14,14 +14,16 @@
 
 """Provides global MediaFileManager object as `media_file_manager`."""
 
+from __future__ import annotations
+
 import collections
 import threading
-from typing import Dict, Optional, Set, Union
+from typing import Final
 
 from streamlit.logger import get_logger
 from streamlit.runtime.media_file_storage import MediaFileKind, MediaFileStorage
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 
 def _get_session_id() -> str:
@@ -80,11 +82,11 @@ class MediaFileManager:
         self._storage = storage
 
         # Dict of [file_id -> MediaFileMetadata]
-        self._file_metadata: Dict[str, MediaFileMetadata] = dict()
+        self._file_metadata: dict[str, MediaFileMetadata] = dict()
 
         # Dict[session ID][coordinates] -> file_id.
-        self._files_by_session_and_coord: Dict[
-            str, Dict[str, str]
+        self._files_by_session_and_coord: dict[
+            str, dict[str, str]
         ] = collections.defaultdict(dict)
 
         # MediaFileManager is used from multiple threads, so all operations
@@ -92,7 +94,7 @@ class MediaFileManager:
         # means taking it multiple times from the same thread will deadlock.)
         self._lock = threading.Lock()
 
-    def _get_inactive_file_ids(self) -> Set[str]:
+    def _get_inactive_file_ids(self) -> set[str]:
         """Compute the set of files that are stored in the manager, but are
         not referenced by any active session. These are files that can be
         safely deleted.
@@ -113,7 +115,7 @@ class MediaFileManager:
 
         Safe to call from any thread.
         """
-        LOGGER.debug("Removing orphaned files...")
+        _LOGGER.debug("Removing orphaned files...")
 
         with self._lock:
             for file_id in self._get_inactive_file_ids():
@@ -132,11 +134,11 @@ class MediaFileManager:
 
         Thread safety: callers must hold `self._lock`.
         """
-        LOGGER.debug("Deleting File: %s", file_id)
+        _LOGGER.debug("Deleting File: %s", file_id)
         self._storage.delete_file(file_id)
         del self._file_metadata[file_id]
 
-    def clear_session_refs(self, session_id: Optional[str] = None) -> None:
+    def clear_session_refs(self, session_id: str | None = None) -> None:
         """Remove the given session's file references.
 
         (This does not remove any files from the manager - you must call
@@ -149,17 +151,17 @@ class MediaFileManager:
         if session_id is None:
             session_id = _get_session_id()
 
-        LOGGER.debug("Disconnecting files for session with ID %s", session_id)
+        _LOGGER.debug("Disconnecting files for session with ID %s", session_id)
 
         with self._lock:
             if session_id in self._files_by_session_and_coord:
                 del self._files_by_session_and_coord[session_id]
 
-        LOGGER.debug(
+        _LOGGER.debug(
             "Sessions still active: %r", self._files_by_session_and_coord.keys()
         )
 
-        LOGGER.debug(
+        _LOGGER.debug(
             "Files: %s; Sessions with files: %s",
             len(self._file_metadata),
             len(self._files_by_session_and_coord),
@@ -167,10 +169,10 @@ class MediaFileManager:
 
     def add(
         self,
-        path_or_data: Union[bytes, str],
+        path_or_data: bytes | str,
         mimetype: str,
         coordinates: str,
-        file_name: Optional[str] = None,
+        file_name: str | None = None,
         is_for_static_download: bool = False,
     ) -> str:
         """Add a new MediaFile with the given parameters and return its URL.

streamlit/runtime/media_file_storage.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from abc import abstractmethod
 from enum import Enum
-from typing import Optional, Union
-
-from typing_extensions import Protocol
+from typing import Protocol
 
 
 class MediaFileKind(Enum):
@@ -43,17 +43,17 @@ class MediaFileStorage(Protocol):
     @abstractmethod
     def load_and_get_id(
         self,
-        path_or_data: Union[str, bytes],
+        path_or_data: str | bytes,
         mimetype: str,
         kind: MediaFileKind,
-        filename: Optional[str] = None,
+        filename: str | None = None,
     ) -> str:
         """Load the given file path or bytes into the manager and return
         an ID that uniquely identifies it.
 
-        It’s an error to pass a URL to this function. (Media stored at
+        It's an error to pass a URL to this function. (Media stored at
         external URLs can be served directly to the Streamlit frontend;
-        there’s no need to store this data in MediaFileStorage.)
+        there's no need to store this data in MediaFileStorage.)
 
         Parameters
         ----------
@@ -61,7 +61,7 @@ class MediaFileStorage(Protocol):
             A path to a file, or the file's raw data as bytes.
 
         mimetype
-            The media’s mimetype. Used to set the Content-Type header when
+            The media's mimetype. Used to set the Content-Type header when
             serving the media over HTTP.
 
         kind

streamlit/runtime/memory_media_file_storage.py

@@ -14,13 +14,13 @@
 
 """MediaFileStorage implementation that stores files in memory."""
 
+from __future__ import annotations
+
 import contextlib
 import hashlib
 import mimetypes
 import os.path
-from typing import Dict, List, NamedTuple, Optional, Union
-
-from typing_extensions import Final
+from typing import Final, NamedTuple
 
 from streamlit.logger import get_logger
 from streamlit.runtime.media_file_storage import (
@@ -31,7 +31,7 @@ from streamlit.runtime.media_file_storage import (
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.util import HASHLIB_KWARGS
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 # Mimetype -> filename extension map for the `get_extension_for_mimetype`
 # function. We use Python's `mimetypes.guess_extension` for most mimetypes,
@@ -42,9 +42,7 @@ PREFERRED_MIMETYPE_EXTENSION_MAP: Final = {
 }
 
 
-def _calculate_file_id(
-    data: bytes, mimetype: str, filename: Optional[str] = None
-) -> str:
+def _calculate_file_id(data: bytes, mimetype: str, filename: str | None = None) -> str:
     """Hash data, mimetype, and an optional filename to generate a stable file ID.
 
     Parameters
@@ -83,7 +81,7 @@ class MemoryFile(NamedTuple):
     content: bytes
     mimetype: str
     kind: MediaFileKind
-    filename: Optional[str]
+    filename: str | None
 
     @property
     def content_size(self) -> int:
@@ -100,15 +98,15 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
             The name of the local endpoint that media is served from.
             This endpoint should start with a forward-slash (e.g. "/media").
         """
-        self._files_by_id: Dict[str, MemoryFile] = {}
+        self._files_by_id: dict[str, MemoryFile] = {}
         self._media_endpoint = media_endpoint
 
     def load_and_get_id(
         self,
-        path_or_data: Union[str, bytes],
+        path_or_data: str | bytes,
         mimetype: str,
         kind: MediaFileKind,
-        filename: Optional[str] = None,
+        filename: str | None = None,
     ) -> str:
         """Add a file to the manager and return its ID."""
         file_data: bytes
@@ -121,7 +119,7 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
         # given ID, we don't need to create a new one.
         file_id = _calculate_file_id(file_data, mimetype, filename)
         if file_id not in self._files_by_id:
-            LOGGER.debug("Adding media file %s", file_id)
+            _LOGGER.debug("Adding media file %s", file_id)
             media_file = MemoryFile(
                 content=file_data, mimetype=mimetype, kind=kind, filename=filename
             )
@@ -167,12 +165,12 @@ class MemoryMediaFileStorage(MediaFileStorage, CacheStatsProvider):
         except Exception as ex:
             raise MediaFileStorageError(f"Error opening '{filename}'") from ex
 
-    def get_stats(self) -> List[CacheStat]:
+    def get_stats(self) -> list[CacheStat]:
         # We operate on a copy of our dict, to avoid race conditions
         # with other threads that may be manipulating the cache.
         files_by_id = self._files_by_id.copy()
 
-        stats: List[CacheStat] = []
+        stats: list[CacheStat] = []
         for file_id, file in files_by_id.items():
             stats.append(
                 CacheStat(

streamlit/runtime/memory_session_storage.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
-from typing import List, MutableMapping, Optional
+from typing import MutableMapping
 
 from streamlit.runtime.session_manager import SessionInfo, SessionStorage
 from streamlit.util import TimedCleanupCache
@@ -59,7 +60,7 @@ class MemorySessionStorage(SessionStorage):
             maxsize=maxsize, ttl=ttl_seconds
         )
 
-    def get(self, session_id: str) -> Optional[SessionInfo]:
+    def get(self, session_id: str) -> SessionInfo | None:
         return self._cache.get(session_id, None)
 
     def save(self, session_info: SessionInfo) -> None:
@@ -68,5 +69,5 @@ class MemorySessionStorage(SessionStorage):
     def delete(self, session_id: str) -> None:
         del self._cache[session_id]
 
-    def list(self) -> List[SessionInfo]:
+    def list(self) -> list[SessionInfo]:
         return list(self._cache.values())

streamlit/runtime/memory_uploaded_file_manager.py

@@ -12,12 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import uuid
 from collections import defaultdict
-from typing import Dict, List, Sequence
+from typing import Sequence
 
 from streamlit import util
-from streamlit.logger import get_logger
 from streamlit.runtime.stats import CacheStat, group_stats
 from streamlit.runtime.uploaded_file_manager import (
     UploadedFileManager,
@@ -25,8 +26,6 @@ from streamlit.runtime.uploaded_file_manager import (
     UploadFileUrlInfo,
 )
 
-LOGGER = get_logger(__name__)
-
 
 class MemoryUploadedFileManager(UploadedFileManager):
     """Holds files uploaded by users of the running Streamlit app.
@@ -34,12 +33,12 @@ class MemoryUploadedFileManager(UploadedFileManager):
     """
 
     def __init__(self, upload_endpoint: str):
-        self.file_storage: Dict[str, Dict[str, UploadedFileRec]] = defaultdict(dict)
+        self.file_storage: dict[str, dict[str, UploadedFileRec]] = defaultdict(dict)
         self.endpoint = upload_endpoint
 
     def get_files(
         self, session_id: str, file_ids: Sequence[str]
-    ) -> List[UploadedFileRec]:
+    ) -> list[UploadedFileRec]:
         """Return a  list of UploadedFileRec for a given sequence of file_ids.
 
         Parameters
@@ -97,7 +96,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
 
     def get_upload_urls(
         self, session_id: str, file_names: Sequence[str]
-    ) -> List[UploadFileUrlInfo]:
+    ) -> list[UploadFileUrlInfo]:
         """Return a list of UploadFileUrlInfo for a given sequence of file_names."""
         result = []
         for _ in file_names:
@@ -111,13 +110,13 @@ class MemoryUploadedFileManager(UploadedFileManager):
             )
         return result
 
-    def get_stats(self) -> List[CacheStat]:
+    def get_stats(self) -> list[CacheStat]:
         """Return the manager's CacheStats.
 
         Safe to call from any thread.
         """
         # Flatten all files into a single list
-        all_files: List[UploadedFileRec] = []
+        all_files: list[UploadedFileRec] = []
         # Make copy of self.file_storage for thread safety, to be sure
         # that main storage won't be changed form other thread
         file_storage_copy = self.file_storage.copy()
@@ -125,7 +124,7 @@ class MemoryUploadedFileManager(UploadedFileManager):
         for session_storage in file_storage_copy.values():
             all_files.extend(session_storage.values())
 
-        stats: List[CacheStat] = [
+        stats: list[CacheStat] = [
             CacheStat(
                 category_name="UploadedFileManager",
                 cache_name="",