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

streamlit/runtime/scriptrunner_utils/script_requests.py

@@ -111,9 +111,9 @@ def _coalesce_widget_states(
     """
     if not old_states and not new_states:
         return None
-    elif not old_states:
+    if not old_states:
         return new_states
-    elif not new_states:
+    if not new_states:
         return old_states
 
     states_by_id: dict[str, WidgetState] = {
@@ -161,7 +161,7 @@ class ScriptRequests:
     ScriptRunner handles those requests.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._lock = threading.Lock()
         self._state = ScriptRequestType.CONTINUE
         self._rerun_data = RerunData()
@@ -284,7 +284,10 @@ class ScriptRequests:
                 self._state = ScriptRequestType.CONTINUE
                 return ScriptRequest(ScriptRequestType.RERUN, self._rerun_data)
 
-            assert self._state == ScriptRequestType.STOP
+            if self._state != ScriptRequestType.STOP:
+                raise RuntimeError(
+                    f"Unrecognized ScriptRunnerState: {self._state}. This should never happen."
+                )
             return ScriptRequest(ScriptRequestType.STOP)
 
     def on_scriptrunner_ready(self) -> ScriptRequest:

streamlit/runtime/scriptrunner_utils/script_run_context.py

@@ -33,7 +33,6 @@ from typing_extensions import TypeAlias
 from streamlit.errors import (
     NoSessionContext,
     StreamlitAPIException,
-    StreamlitSetPageConfigMustBeFirstCommandError,
 )
 from streamlit.logger import get_logger
 from streamlit.runtime.forward_msg_cache import (
@@ -42,6 +41,7 @@ from streamlit.runtime.forward_msg_cache import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
     from pathlib import Path
 
     from streamlit.cursor import RunningCursor
@@ -97,7 +97,6 @@ class ScriptRunContext:
     command_tracking_deactivated: bool = False
     tracked_commands: list[Command] = field(default_factory=list)
     tracked_commands_counter: Counter[str] = field(default_factory=collections.Counter)
-    _set_page_config_allowed: bool = True
     _has_script_started: bool = False
     widget_ids_this_run: set[str] = field(default_factory=set)
     widget_user_keys_this_run: set[str] = field(default_factory=set)
@@ -107,6 +106,7 @@ class ScriptRunContext:
     current_fragment_id: str | None = None
     fragment_ids_this_run: list[str] | None = None
     new_fragment_ids: set[str] = field(default_factory=set)
+    in_fragment_callback: bool = False
     _active_script_hash: str = ""
     # we allow only one dialog to be open at the same time
     has_dialog_opened: bool = False
@@ -116,11 +116,11 @@ class ScriptRunContext:
     _production_query_params_used = False
 
     @property
-    def page_script_hash(self):
+    def page_script_hash(self) -> str:
         return self.pages_manager.current_page_script_hash
 
     @property
-    def active_script_hash(self):
+    def active_script_hash(self) -> str:
         return self._active_script_hash
 
     @property
@@ -128,7 +128,7 @@ class ScriptRunContext:
         return self.pages_manager.main_script_parent
 
     @contextlib.contextmanager
-    def run_with_active_hash(self, page_hash: str):
+    def run_with_active_hash(self, page_hash: str) -> Generator[None, None, None]:
         original_page_hash = self._active_script_hash
         self._active_script_hash = page_hash
         try:
@@ -137,7 +137,7 @@ class ScriptRunContext:
             # in the event of any exception, ensure we set the active hash back
             self._active_script_hash = original_page_hash
 
-    def set_mpa_v2_page(self, page_script_hash: str):
+    def set_mpa_v2_page(self, page_script_hash: str) -> None:
         self._active_script_hash = self.pages_manager.main_script_hash
         self.pages_manager.set_current_page_script_hash(page_script_hash)
 
@@ -157,8 +157,6 @@ class ScriptRunContext:
         self.context_info = context_info
         self.pages_manager.set_current_page_script_hash(page_script_hash)
         self._active_script_hash = self.pages_manager.main_script_hash
-        # Permit set_page_config when the ScriptRunContext is reused on a rerun
-        self._set_page_config_allowed = True
         self._has_script_started = False
         self.command_tracking_deactivated: bool = False
         self.tracked_commands = []
@@ -188,17 +186,6 @@ class ScriptRunContext:
 
     def enqueue(self, msg: ForwardMsg) -> None:
         """Enqueue a ForwardMsg for this context's session."""
-        if msg.HasField("page_config_changed") and not self._set_page_config_allowed:
-            raise StreamlitSetPageConfigMustBeFirstCommandError()
-
-        # We want to disallow set_page config if one of the following occurs:
-        # - set_page_config was called on this message
-        # - The script has already started and a different st call occurs (a delta)
-        if msg.HasField("page_config_changed") or (
-            msg.HasField("delta") and self._has_script_started
-        ):
-            self._set_page_config_allowed = False
-
         msg.metadata.active_script_hash = self.active_script_hash
 
         # We populate the hash and cacheable field for all messages.
@@ -217,7 +204,7 @@ class ScriptRunContext:
         # Pass the message up to our associated ScriptRunner.
         self._enqueue(msg_to_send)
 
-    def ensure_single_query_api_used(self):
+    def ensure_single_query_api_used(self) -> None:
         if self._experimental_query_params_used and self._production_query_params_used:
             raise StreamlitAPIException(
                 "Using `st.query_params` together with either `st.experimental_get_query_params` "
@@ -225,11 +212,11 @@ class ScriptRunContext:
                 " convert your app to only use `st.query_params`"
             )
 
-    def mark_experimental_query_params_used(self):
+    def mark_experimental_query_params_used(self) -> None:
         self._experimental_query_params_used = True
         self.ensure_single_query_api_used()
 
-    def mark_production_query_params_used(self):
+    def mark_production_query_params_used(self) -> None:
         self._production_query_params_used = True
         self.ensure_single_query_api_used()
 
@@ -239,7 +226,7 @@ SCRIPT_RUN_CONTEXT_ATTR_NAME: Final = "streamlit_script_run_ctx"
 
 def add_script_run_ctx(
     thread: threading.Thread | None = None, ctx: ScriptRunContext | None = None
-):
+) -> threading.Thread:
     """Adds the current ScriptRunContext to a newly-created thread.
 
     This should be called from this thread's parent thread,

streamlit/runtime/secrets.py

@@ -27,9 +27,8 @@ from typing import (
 
 from blinker import Signal
 
-import streamlit as st
 import streamlit.watcher.path_watcher
-from streamlit import runtime
+from streamlit import config, runtime
 from streamlit.errors import StreamlitSecretNotFoundError
 from streamlit.logger import get_logger
 
@@ -37,34 +36,40 @@ _LOGGER: Final = get_logger(__name__)
 
 
 class SecretErrorMessages:
-    """SecretErrorMessages stores all error messages we use for secrets to allow customization for different environments.
+    """SecretErrorMessages stores all error messages we use for secrets to allow customization
+    for different environments.
+
     For example Streamlit Cloud can customize the message to be different than the open source.
 
     For internal use, may change in future releases without notice.
     """
 
-    def __init__(self):
-        self.missing_attr_message = lambda attr_name: (
+    def __init__(self) -> None:
+        self.missing_attr_message: Callable[[str], str] = lambda attr_name: (
             f'st.secrets has no attribute "{attr_name}". '
-            f"Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings on Streamlit Cloud? "
-            f"More info: https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
+            "Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings "
+            "on Streamlit Cloud? More info: "
+            "https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
         )
-        self.missing_key_message = lambda key: (
+        self.missing_key_message: Callable[[str], str] = lambda key: (
             f'st.secrets has no key "{key}". '
-            f"Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings on Streamlit Cloud? "
-            f"More info: https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
+            "Did you forget to add it to secrets.toml, mount it to secret directory, or the app settings "
+            "on Streamlit Cloud? More info: "
+            "https://docs.streamlit.io/deploy/streamlit-community-cloud/deploy-your-app/secrets-management"
         )
-        self.no_secrets_found = lambda file_paths: (
+        self.no_secrets_found: Callable[[list[str]], str] = lambda file_paths: (
             f"No secrets found. Valid paths for a secrets.toml file or secret directories are: {', '.join(file_paths)}"
         )
-        self.error_parsing_file_at_path = (
+        self.error_parsing_file_at_path: Callable[[str, Exception], str] = (
             lambda path, ex: f"Error parsing secrets file at {path}: {ex}"
         )
-        self.subfolder_path_is_not_a_folder = lambda sub_folder_path: (
-            f"{sub_folder_path} is not a folder. "
-            "To use directory based secrets, mount every secret in a subfolder under the secret directory"
+        self.subfolder_path_is_not_a_folder: Callable[[str], str] = (
+            lambda sub_folder_path: (
+                f"{sub_folder_path} is not a folder. "
+                "To use directory based secrets, mount every secret in a subfolder under the secret directory"
+            )
         )
-        self.invalid_secret_path = lambda path: (
+        self.invalid_secret_path: Callable[[str], str] = lambda path: (
             f"Invalid secrets path: {path}: path is not a .toml file or a directory"
         )
 
@@ -144,15 +149,14 @@ class AttrDict(Mapping[str, Any]):
     to provide dot access to nested secrets.
     """
 
-    def __init__(self, value):
+    def __init__(self, value: Mapping[str, Any]) -> None:
         self.__dict__["__nested_secrets__"] = dict(value)
 
     @staticmethod
-    def _maybe_wrap_in_attr_dict(value) -> Any:
+    def _maybe_wrap_in_attr_dict(value: Any) -> Any:
         if not isinstance(value, Mapping):
             return value
-        else:
-            return AttrDict(value)
+        return AttrDict(value)
 
     def __len__(self) -> int:
         return len(self.__nested_secrets__)
@@ -174,13 +178,13 @@ class AttrDict(Mapping[str, Any]):
         except KeyError:
             raise AttributeError(_missing_attr_error_message(attr_name))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return repr(self.__nested_secrets__)
 
-    def __setitem__(self, key, value) -> NoReturn:
+    def __setitem__(self, key: str, value: Any) -> NoReturn:
         raise TypeError("Secrets does not support item assignment.")
 
-    def __setattr__(self, key, value) -> NoReturn:
+    def __setattr__(self, key: str, value: Any) -> NoReturn:
         raise TypeError("Secrets does not support attribute assignment.")
 
     def to_dict(self) -> dict[str, Any]:
@@ -194,7 +198,7 @@ class Secrets(Mapping[str, Any]):
     Safe to use from multiple threads.
     """
 
-    def __init__(self):
+    def __init__(self) -> None:
         # Our secrets dict.
         self._secrets: Mapping[str, Any] | None = None
         self._lock = threading.RLock()
@@ -272,7 +276,8 @@ class Secrets(Mapping[str, Any]):
         return secrets, found_secrets_file
 
     def _parse_directory(self, path: str) -> tuple[Mapping[str, Any], bool]:
-        """Parse a directory for secrets. Directory style can be used to support Kubernetes secrets that are mounted to folders.
+        """Parse a directory for secrets. Directory style can be used to support Kubernetes secrets that are
+        mounted to folders.
 
         Example structure:
         - top_level_secret_folder
@@ -310,7 +315,7 @@ class Secrets(Mapping[str, Any]):
 
             if len(sub_secrets) == 1:
                 # if there's just one file, collapse it so it's directly under `dirname`
-                secrets[dirname] = sub_secrets[list(sub_secrets.keys())[0]]
+                secrets[dirname] = sub_secrets[next(iter(sub_secrets.keys()))]
             else:
                 secrets[dirname] = sub_secrets
 
@@ -356,7 +361,7 @@ class Secrets(Mapping[str, Any]):
 
             secrets = {}
 
-            file_paths = st.config.get_option("secrets.files")
+            file_paths = config.get_option("secrets.files")
             found_secrets_file = False
             for path in file_paths:
                 path_secrets, found_secrets_file_in_path = self._parse_file_path(path)
@@ -380,7 +385,9 @@ class Secrets(Mapping[str, Any]):
             return self._secrets
 
     def to_dict(self) -> dict[str, Any]:
-        """Converts the secrets store into a nested dictionary, where nested AttrDict objects are also converted into dictionaries."""
+        """Converts the secrets store into a nested dictionary, where nested AttrDict objects are
+        also converted into dictionaries.
+        """
         secrets = self._parse()
         return _convert_to_dict(secrets)
 
@@ -407,7 +414,7 @@ class Secrets(Mapping[str, Any]):
             if self._file_watchers_installed:
                 return
 
-            file_paths = st.config.get_option("secrets.files")
+            file_paths = config.get_option("secrets.files")
             for path in file_paths:
                 try:
                     if path.endswith(".toml"):
@@ -422,7 +429,7 @@ class Secrets(Mapping[str, Any]):
                             self._on_secrets_changed,
                             watcher_type="poll",
                         )
-                except FileNotFoundError:
+                except FileNotFoundError:  # noqa: PERF203
                     # A user may only have one secrets.toml file defined, so we'd expect
                     # FileNotFoundErrors to be raised when attempting to install a
                     # watcher on the nonexistent ones.
@@ -432,7 +439,7 @@ class Secrets(Mapping[str, Any]):
             # failed to avoid repeatedly trying to install it.
             self._file_watchers_installed = True
 
-    def _on_secrets_changed(self, changed_file_path) -> None:
+    def _on_secrets_changed(self, changed_file_path: str) -> None:
         with self._lock:
             _LOGGER.debug("Secret path %s changed, reloading", changed_file_path)
             self._reset()
@@ -452,8 +459,7 @@ class Secrets(Mapping[str, Any]):
             value = self._parse()[key]
             if not isinstance(value, Mapping):
                 return value
-            else:
-                return AttrDict(value)
+            return AttrDict(value)
         # We add FileNotFoundError since __getattr__ is expected to only raise
         # AttributeError. Without handling FileNotFoundError, unittests.mocks
         # fails during mock creation on Python3.9
@@ -470,8 +476,7 @@ class Secrets(Mapping[str, Any]):
             value = self._parse()[key]
             if not isinstance(value, Mapping):
                 return value
-            else:
-                return AttrDict(value)
+            return AttrDict(value)
         except KeyError:
             raise KeyError(_missing_key_error_message(key))
 

streamlit/runtime/session_manager.py

@@ -72,7 +72,8 @@ class SessionInfo:
         return self.client is not None
 
     def to_active(self) -> ActiveSessionInfo:
-        assert self.is_active(), "A SessionInfo with no client cannot be active!"
+        if not self.is_active():
+            raise RuntimeError("A SessionInfo with no client cannot be active!")
 
         # NOTE: The cast here (rather than copying this SessionInfo's fields into a new
         # ActiveSessionInfo) is important as the Runtime expects to be able to mutate

streamlit/runtime/state/__init__.py

@@ -27,15 +27,15 @@ from streamlit.runtime.state.session_state_proxy import (
 from streamlit.runtime.state.widgets import register_widget
 
 __all__ = [
-    "WidgetArgs",
-    "WidgetCallback",
-    "WidgetKwargs",
+    "SCRIPT_RUN_WITHOUT_ERRORS_KEY",
     "QueryParamsProxy",
     "SafeSessionState",
-    "SCRIPT_RUN_WITHOUT_ERRORS_KEY",
     "SessionState",
-    "SessionStateStatProvider",
     "SessionStateProxy",
+    "SessionStateStatProvider",
+    "WidgetArgs",
+    "WidgetCallback",
+    "WidgetKwargs",
     "get_session_state",
     "register_widget",
 ]

streamlit/runtime/state/common.py

@@ -51,7 +51,7 @@ WidgetCallback: TypeAlias = Callable[..., None]
 # WidgetState proto, and returns a regular python value. A serializer
 # receives a regular python value, and returns something suitable for
 # a value field on WidgetState proto. They should be inverses.
-WidgetDeserializer: TypeAlias = Callable[[Any, str], T]
+WidgetDeserializer: TypeAlias = Callable[[Any], T]
 WidgetSerializer: TypeAlias = Callable[[T], Any]
 
 # The array value field names are part of the larger set of possible value
@@ -156,7 +156,7 @@ class RegisterWidgetResult(Generic[T_co]):
         """The canonical way to construct a RegisterWidgetResult in cases
         where the true widget value could not be determined.
         """
-        return cls(value=deserializer(None, ""), value_changed=False)
+        return cls(value=deserializer(None), value_changed=False)
 
 
 def user_key_from_element_id(element_id: str) -> str | None:

streamlit/runtime/state/query_params.py

@@ -47,9 +47,7 @@ class QueryParams(MutableMapping[str, str]):
         self._ensure_single_query_api_used()
 
         return iter(
-            key
-            for key in self._query_params.keys()
-            if key not in EMBED_QUERY_PARAMS_KEYS
+            key for key in self._query_params if key not in EMBED_QUERY_PARAMS_KEYS
         )
 
     def __getitem__(self, key: str) -> str:
@@ -58,17 +56,17 @@ class QueryParams(MutableMapping[str, str]):
         If the key is not present, raise KeyError.
         """
         self._ensure_single_query_api_used()
+        if key in EMBED_QUERY_PARAMS_KEYS:
+            raise KeyError(missing_key_error_message(key))
+
         try:
-            if key in EMBED_QUERY_PARAMS_KEYS:
-                raise KeyError(missing_key_error_message(key))
             value = self._query_params[key]
             if isinstance(value, list):
                 if len(value) == 0:
                     return ""
-                else:
-                    # Return the last value to mimic Tornado's behavior
-                    # https://www.tornadoweb.org/en/stable/web.html#tornado.web.RequestHandler.get_query_argument
-                    return value[-1]
+                # Return the last value to mimic Tornado's behavior
+                # https://www.tornadoweb.org/en/stable/web.html#tornado.web.RequestHandler.get_query_argument
+                return value[-1]
             return value
         except KeyError:
             raise KeyError(missing_key_error_message(key))
@@ -97,9 +95,9 @@ class QueryParams(MutableMapping[str, str]):
 
     def __delitem__(self, key: str) -> None:
         self._ensure_single_query_api_used()
+        if key in EMBED_QUERY_PARAMS_KEYS:
+            raise KeyError(missing_key_error_message(key))
         try:
-            if key in EMBED_QUERY_PARAMS_KEYS:
-                raise KeyError(missing_key_error_message(key))
             del self._query_params[key]
             self._send_query_param_msg()
         except KeyError:
@@ -111,12 +109,12 @@ class QueryParams(MutableMapping[str, str]):
         | SupportsKeysAndGetItem[str, str | Iterable[str]] = (),
         /,
         **kwds: str,
-    ):
+    ) -> None:
         # This overrides the `update` provided by MutableMapping
         # to ensure only one one ForwardMsg is sent.
         self._ensure_single_query_api_used()
         if hasattr(other, "keys") and hasattr(other, "__getitem__"):
-            for key in other.keys():
+            for key in other.keys():  # noqa: SIM118
                 self.__set_item_internal(key, other[key])
         else:
             for key, value in other:
@@ -173,7 +171,7 @@ class QueryParams(MutableMapping[str, str]):
         self,
         _dict: Iterable[tuple[str, str | Iterable[str]]]
         | SupportsKeysAndGetItem[str, str | Iterable[str]],
-    ):
+    ) -> None:
         self._ensure_single_query_api_used()
         old_value = self._query_params.copy()
         self.clear_with_no_forward_msg(preserve_embed=True)
@@ -194,7 +192,7 @@ class QueryParams(MutableMapping[str, str]):
             if key in EMBED_QUERY_PARAMS_KEYS and preserve_embed
         }
 
-    def _ensure_single_query_api_used(self):
+    def _ensure_single_query_api_used(self) -> None:
         ctx = get_script_run_ctx()
         if ctx is None:
             return

streamlit/runtime/state/query_params_proxy.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from collections.abc import Iterable, Iterator, MutableMapping
-from typing import TYPE_CHECKING, overload
+from typing import TYPE_CHECKING, Any, overload
 
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.state.session_state_proxy import get_session_state
@@ -55,7 +55,7 @@ class QueryParamsProxy(MutableMapping[str, str]):
             del qp[key]
 
     @gather_metrics("query_params.set_item")
-    def __setitem__(self, key: str, value: str | Iterable[str]) -> None:
+    def __setitem__(self, key: str, value: Any) -> None:
         with get_session_state().query_params() as qp:
             qp[key] = value
 
@@ -76,18 +76,18 @@ class QueryParamsProxy(MutableMapping[str, str]):
 
     @overload
     def update(
-        self, mapping: SupportsKeysAndGetItem[str, str | Iterable[str]], /, **kwds: str
+        self, params: SupportsKeysAndGetItem[str, str | Iterable[str]], /, **kwds: str
     ) -> None: ...
 
     @overload
     def update(
-        self, keys_and_values: Iterable[tuple[str, str | Iterable[str]]], /, **kwds: str
+        self, params: Iterable[tuple[str, str | Iterable[str]]], /, **kwds: str
     ) -> None: ...
 
     @overload
     def update(self, **kwds: str | Iterable[str]) -> None: ...
 
-    def update(self, other=(), /, **kwds):
+    def update(self, params=(), /, **kwds) -> None:  # type: ignore
         """
         Update one or more values in query_params at once from a dictionary or
         dictionary-like object.
@@ -102,10 +102,10 @@ class QueryParamsProxy(MutableMapping[str, str]):
             Additional key/value pairs to update passed as keyword arguments.
         """
         with get_session_state().query_params() as qp:
-            qp.update(other, **kwds)
+            qp.update(params, **kwds)
 
     @gather_metrics("query_params.set_attr")
-    def __setattr__(self, key: str, value: str | Iterable[str]) -> None:
+    def __setattr__(self, key: str, value: Any) -> None:
         with get_session_state().query_params() as qp:
             qp[key] = value
 
@@ -159,23 +159,25 @@ class QueryParamsProxy(MutableMapping[str, str]):
         Returns
         -------
         Dict[str,str]
-            A dictionary of the current query paramters in the app's URL.
+            A dictionary of the current query parameters in the app's URL.
         """
         with get_session_state().query_params() as qp:
             return qp.to_dict()
 
     @overload
-    def from_dict(
-        self, keys_and_values: Iterable[tuple[str, str | Iterable[str]]]
-    ) -> None: ...
+    def from_dict(self, params: Iterable[tuple[str, str | Iterable[str]]]) -> None: ...
 
     @overload
     def from_dict(
-        self, mapping: SupportsKeysAndGetItem[str, str | Iterable[str]]
+        self, params: SupportsKeysAndGetItem[str, str | Iterable[str]]
     ) -> None: ...
 
     @gather_metrics("query_params.from_dict")
-    def from_dict(self, params):
+    def from_dict(
+        self,
+        params: SupportsKeysAndGetItem[str, str | Iterable[str]]
+        | Iterable[tuple[str, str | Iterable[str]]],
+    ) -> None:
         """
         Set all of the query parameters from a dictionary or dictionary-like object.
 
@@ -211,8 +213,10 @@ class QueryParamsProxy(MutableMapping[str, str]):
 
     @staticmethod
     def missing_key_error_message(key: str) -> str:
+        """Returns a formatted error message for missing keys."""
         return f'st.query_params has no key "{key}".'
 
     @staticmethod
     def missing_attr_error_message(key: str) -> str:
+        """Returns a formatted error message for missing attributes."""
         return f'st.query_params has no attribute "{key}".'

streamlit/runtime/state/safe_session_state.py

@@ -42,7 +42,7 @@ class SafeSessionState:
     _lock: threading.RLock
     _yield_callback: Callable[[], None]
 
-    def __init__(self, state: SessionState, yield_callback: Callable[[], None]):
+    def __init__(self, state: SessionState, yield_callback: Callable[[], None]) -> None:
         # Fields must be set using the object's setattr method to avoid
         # infinite recursion from trying to look up the fields we're setting.
         object.__setattr__(self, "_state", state)
@@ -125,7 +125,7 @@ class SafeSessionState:
         except KeyError:
             raise AttributeError(f"{key} not found in session_state.")
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         """Presents itself as a simple dict of the underlying SessionState instance."""
         kv = ((k, self._state[k]) for k in self._state._keys())
         s = ", ".join(f"{k}: {v!r}" for k, v in kv)