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

streamlit/runtime/forward_msg_cache.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import hashlib
-from typing import TYPE_CHECKING, Dict, List, MutableMapping, Optional
+from typing import TYPE_CHECKING, Final, MutableMapping
 from weakref import WeakKeyDictionary
 
 from streamlit import config, util
@@ -25,7 +27,7 @@ from streamlit.util import HASHLIB_KWARGS
 if TYPE_CHECKING:
     from streamlit.runtime.app_session import AppSession
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 
 def populate_hash_if_needed(msg: ForwardMsg) -> str:
@@ -107,16 +109,16 @@ class ForwardMsgCache(CacheStatsProvider):
 
         """
 
-        def __init__(self, msg: Optional[ForwardMsg]):
+        def __init__(self, msg: ForwardMsg | None):
             self.msg = msg
             self._session_script_run_counts: MutableMapping[
-                "AppSession", int
+                AppSession, int
             ] = WeakKeyDictionary()
 
         def __repr__(self) -> str:
             return util.repr_(self)
 
-        def add_session_ref(self, session: "AppSession", script_run_count: int) -> None:
+        def add_session_ref(self, session: AppSession, script_run_count: int) -> None:
             """Adds a reference to a AppSession that has referenced
             this Entry's message.
 
@@ -129,18 +131,18 @@ class ForwardMsgCache(CacheStatsProvider):
             """
             prev_run_count = self._session_script_run_counts.get(session, 0)
             if script_run_count < prev_run_count:
-                LOGGER.error(
+                _LOGGER.error(
                     "New script_run_count (%s) is < prev_run_count (%s). "
                     "This should never happen!" % (script_run_count, prev_run_count)
                 )
                 script_run_count = prev_run_count
             self._session_script_run_counts[session] = script_run_count
 
-        def has_session_ref(self, session: "AppSession") -> bool:
+        def has_session_ref(self, session: AppSession) -> bool:
             return session in self._session_script_run_counts
 
         def get_session_ref_age(
-            self, session: "AppSession", script_run_count: int
+            self, session: AppSession, script_run_count: int
         ) -> int:
             """The age of the given session's reference to the Entry,
             given a new script_run_count.
@@ -148,7 +150,7 @@ class ForwardMsgCache(CacheStatsProvider):
             """
             return script_run_count - self._session_script_run_counts[session]
 
-        def remove_session_ref(self, session: "AppSession") -> None:
+        def remove_session_ref(self, session: AppSession) -> None:
             del self._session_script_run_counts[session]
 
         def has_refs(self) -> bool:
@@ -159,13 +161,13 @@ class ForwardMsgCache(CacheStatsProvider):
             return len(self._session_script_run_counts) > 0
 
     def __init__(self):
-        self._entries: Dict[str, "ForwardMsgCache.Entry"] = {}
+        self._entries: dict[str, ForwardMsgCache.Entry] = {}
 
     def __repr__(self) -> str:
         return util.repr_(self)
 
     def add_message(
-        self, msg: ForwardMsg, session: "AppSession", script_run_count: int
+        self, msg: ForwardMsg, session: AppSession, script_run_count: int
     ) -> None:
         """Add a ForwardMsg to the cache.
 
@@ -191,7 +193,7 @@ class ForwardMsgCache(CacheStatsProvider):
             self._entries[msg.hash] = entry
         entry.add_session_ref(session, script_run_count)
 
-    def get_message(self, hash: str) -> Optional[ForwardMsg]:
+    def get_message(self, hash: str) -> ForwardMsg | None:
         """Return the message with the given ID if it exists in the cache.
 
         Parameters
@@ -208,7 +210,7 @@ class ForwardMsgCache(CacheStatsProvider):
         return entry.msg if entry else None
 
     def has_message_reference(
-        self, msg: ForwardMsg, session: "AppSession", script_run_count: int
+        self, msg: ForwardMsg, session: AppSession, script_run_count: int
     ) -> bool:
         """Return True if a session has a reference to a message."""
         populate_hash_if_needed(msg)
@@ -221,7 +223,7 @@ class ForwardMsgCache(CacheStatsProvider):
         age = entry.get_session_ref_age(session, script_run_count)
         return age <= int(config.get_option("global.maxCachedMessageAge"))
 
-    def remove_refs_for_session(self, session: "AppSession") -> None:
+    def remove_refs_for_session(self, session: AppSession) -> None:
         """Remove refs for all entries for the given session.
 
         This should be called when an AppSession is disconnected or closed.
@@ -243,7 +245,7 @@ class ForwardMsgCache(CacheStatsProvider):
                 del self._entries[msg_hash]
 
     def remove_expired_entries_for_session(
-        self, session: "AppSession", script_run_count: int
+        self, session: AppSession, script_run_count: int
     ) -> None:
         """Remove any cached messages that have expired from the given session.
 
@@ -266,7 +268,7 @@ class ForwardMsgCache(CacheStatsProvider):
 
             age = entry.get_session_ref_age(session, script_run_count)
             if age > max_age:
-                LOGGER.debug(
+                _LOGGER.debug(
                     "Removing expired entry [session=%s, hash=%s, age=%s]",
                     id(session),
                     msg_hash,
@@ -282,8 +284,8 @@ class ForwardMsgCache(CacheStatsProvider):
         """Remove all entries from the cache"""
         self._entries.clear()
 
-    def get_stats(self) -> List[CacheStat]:
-        stats: List[CacheStat] = []
+    def get_stats(self) -> list[CacheStat]:
+        stats: list[CacheStat] = []
         for entry_hash, entry in self._entries.items():
             stats.append(
                 CacheStat(

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/legacy_caching/hashing.py

@@ -14,12 +14,12 @@
 
 """A hashing utility for code."""
 
+from __future__ import annotations
+
 import collections
-import dis
 import enum
 import functools
 import hashlib
-import importlib
 import inspect
 import io
 import os
@@ -28,9 +28,8 @@ import sys
 import tempfile
 import textwrap
 import threading
-import unittest.mock
 import weakref
-from typing import Any, Callable, Dict, List, Optional, Pattern, Type, Union
+from typing import Any, Callable, Dict, Pattern, Type, Union
 
 from streamlit import config, file_util, type_util, util
 from streamlit.errors import MarkdownFormattedException, StreamlitAPIException
@@ -95,8 +94,8 @@ def update_hash(
     hasher,
     hash_reason: HashReason,
     hash_source: Callable[..., Any],
-    context: Optional[Context] = None,
-    hash_funcs: Optional[HashFuncsDict] = None,
+    context: Context | None = None,
+    hash_funcs: HashFuncsDict | None = None,
 ) -> None:
     """Updates a hashlib hasher with the hash of val.
 
@@ -122,15 +121,15 @@ class _HashStack:
     """
 
     def __init__(self):
-        self._stack: collections.OrderedDict[int, List[Any]] = collections.OrderedDict()
+        self._stack: collections.OrderedDict[int, list[Any]] = collections.OrderedDict()
 
         # The reason why we're doing this hashing, for debug purposes.
-        self.hash_reason: Optional[HashReason] = None
+        self.hash_reason: HashReason | None = None
 
         # Either a function or a code block, depending on whether the reason is
         # due to hashing part of a function (i.e. body, args, output) or an
         # st.Cache codeblock.
-        self.hash_source: Optional[Callable[..., Any]] = None
+        self.hash_source: Callable[..., Any] | None = None
 
     def __repr__(self) -> str:
         return util.repr_(self)
@@ -147,7 +146,7 @@ class _HashStack:
     def pretty_print(self):
         def to_str(v):
             try:
-                return "Object of type %s: %s" % (type_util.get_fqn_type(v), str(v))
+                return "Object of type {}: {}".format(type_util.get_fqn_type(v), str(v))
             except Exception:
                 return "<Unable to convert item to string>"
 
@@ -272,7 +271,7 @@ def _int_to_bytes(i: int) -> bytes:
     return i.to_bytes(num_bytes, "little", signed=True)
 
 
-def _key(obj: Optional[Any]) -> Any:
+def _key(obj: Any | None) -> Any:
     """Return key for memoization."""
 
     if obj is None:
@@ -315,7 +314,7 @@ def _key(obj: Optional[Any]) -> Any:
 class _CodeHasher:
     """A hasher that can hash code objects including dependencies."""
 
-    def __init__(self, hash_funcs: Optional[HashFuncsDict] = None):
+    def __init__(self, hash_funcs: HashFuncsDict | 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.
@@ -332,7 +331,7 @@ class _CodeHasher:
         else:
             self._hash_funcs = {}
 
-        self._hashes: Dict[Any, bytes] = {}
+        self._hashes: dict[Any, bytes] = {}
 
         # The number of the bytes in the hash.
         self.size = 0
@@ -340,7 +339,7 @@ class _CodeHasher:
     def __repr__(self) -> str:
         return util.repr_(self)
 
-    def to_bytes(self, obj: Any, context: Optional[Context] = None) -> bytes:
+    def to_bytes(self, obj: Any, context: Context | None = None) -> bytes:
         """Add memoization to _to_bytes and protect against cycles in data structures."""
         tname = type(obj).__qualname__.encode()
         key = (tname, _key(obj))
@@ -381,7 +380,7 @@ class _CodeHasher:
 
         return b
 
-    def update(self, hasher, obj: Any, context: Optional[Context] = None) -> None:
+    def update(self, hasher, obj: Any, context: Context | None = None) -> None:
         """Update the provided hasher with the hash of an object."""
         b = self.to_bytes(obj, context)
         hasher.update(b)
@@ -403,7 +402,7 @@ class _CodeHasher:
             filepath, self._get_main_script_directory()
         ) or file_util.file_in_pythonpath(filepath)
 
-    def _to_bytes(self, obj: Any, context: Optional[Context]) -> bytes:
+    def _to_bytes(self, obj: Any, context: Context | None) -> bytes:
         """Hash objects to bytes, including code with dependencies.
 
         Python's built in `hash` does not produce consistent results across
@@ -412,7 +411,9 @@ class _CodeHasher:
 
         h = hashlib.new("md5", **HASHLIB_KWARGS)
 
-        if isinstance(obj, unittest.mock.Mock):
+        if type_util.is_type(obj, "unittest.mock.Mock") or type_util.is_type(
+            obj, "unittest.mock.MagicMock"
+        ):
             # Mock objects can appear to be infinitely
             # deep, so we don't try to hash them at all.
             return self.to_bytes(id(obj))
@@ -615,7 +616,7 @@ class _CodeHasher:
             if obj.__module__.startswith("streamlit"):
                 # Ignore streamlit modules even if they are in the CWD
                 # (e.g. during development).
-                return self.to_bytes("%s.%s" % (obj.__module__, obj.__name__))
+                return self.to_bytes("{}.{}".format(obj.__module__, obj.__name__))
 
             code = getattr(obj, "__code__", None)
             assert code is not None
@@ -710,11 +711,11 @@ class _CodeHasher:
         return str(abs_main_path.parent)
 
 
-def get_referenced_objects(code, context: Context) -> List[Any]:
+def get_referenced_objects(code, context: Context) -> list[Any]:
     # Top of the stack
     tos: Any = None
     lineno = None
-    refs: List[Any] = []
+    refs: list[Any] = []
 
     def set_tos(t):
         nonlocal tos
@@ -729,6 +730,7 @@ def get_referenced_objects(code, context: Context) -> List[Any]:
     # code reads `bar` of `foo`. We are going over the bytecode to resolve
     # from which object an attribute is requested.
     # Read more about bytecode at https://docs.python.org/3/library/dis.html
+    import dis
 
     for op in dis.get_instructions(code):
         try:
@@ -747,6 +749,8 @@ def get_referenced_objects(code, context: Context) -> List[Any]:
                 set_tos(context.cells.values[op.argval])
             elif op.opname == "IMPORT_NAME":
                 try:
+                    import importlib
+
                     set_tos(importlib.import_module(op.argval))
                 except ImportError:
                     set_tos(op.argval)
@@ -785,7 +789,7 @@ class NoResult:
 class UnhashableTypeError(StreamlitAPIException):
     def __init__(self, orig_exc, failed_obj):
         msg = self._get_message(orig_exc, failed_obj)
-        super(UnhashableTypeError, self).__init__(msg)
+        super().__init__(msg)
         self.with_traceback(orig_exc.__traceback__)
 
     def _get_message(self, orig_exc, failed_obj):
@@ -834,7 +838,7 @@ class UserHashError(StreamlitAPIException):
         else:
             msg = self._get_message_from_code(orig_exc, cached_func_or_code, lineno)
 
-        super(UserHashError, self).__init__(msg)
+        super().__init__(msg)
         self.with_traceback(orig_exc.__traceback__)
 
     def _get_message_from_func(self, orig_exc, cached_func, hash_func):
@@ -906,7 +910,7 @@ class InternalHashError(MarkdownFormattedException):
 
     def __init__(self, orig_exc: BaseException, failed_obj: Any):
         msg = self._get_message(orig_exc, failed_obj)
-        super(InternalHashError, self).__init__(msg)
+        super().__init__(msg)
         self.with_traceback(orig_exc.__traceback__)
 
     def _get_message(self, orig_exc: BaseException, failed_obj: Any) -> str:
@@ -949,7 +953,7 @@ for more details.
         ).strip("\n")
 
 
-def _get_error_message_args(orig_exc: BaseException, failed_obj: Any) -> Dict[str, Any]:
+def _get_error_message_args(orig_exc: BaseException, failed_obj: Any) -> dict[str, Any]:
     hash_reason = hash_stacks.current.hash_reason
     hash_source = hash_stacks.current.hash_source
 
@@ -984,7 +988,7 @@ def _get_error_message_args(orig_exc: BaseException, failed_obj: Any) -> Dict[st
     }
 
 
-def _get_failing_lines(code, lineno: int) -> List[str]:
+def _get_failing_lines(code, lineno: int) -> list[str]:
     """Get list of strings (lines of code) from lineno to lineno+3.
 
     Ideally we'd return the exact line where the error took place, but there