streamlit-nightly 1.43.2.dev20250307__py3-none-any.whl

streamlit/elements/lib/dialog.py

@@ -0,0 +1,147 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal, cast
+
+from typing_extensions import Self, TypeAlias
+
+from streamlit.delta_generator import DeltaGenerator
+from streamlit.errors import StreamlitAPIException
+from streamlit.proto.Block_pb2 import Block as BlockProto
+from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+from streamlit.runtime.scriptrunner_utils.script_run_context import (
+    enqueue_message,
+    get_script_run_ctx,
+)
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from streamlit.cursor import Cursor
+
+DialogWidth: TypeAlias = Literal["small", "large"]
+
+
+def _process_dialog_width_input(
+    width: DialogWidth,
+) -> BlockProto.Dialog.DialogWidth.ValueType:
+    """Maps the user-provided literal to a value of the DialogWidth proto enum.
+
+    Returns the mapped enum field for "small" by default and otherwise the mapped type.
+    """
+    if width == "large":
+        return BlockProto.Dialog.DialogWidth.LARGE
+
+    return BlockProto.Dialog.DialogWidth.SMALL
+
+
+def _assert_first_dialog_to_be_opened(should_open: bool) -> None:
+    """Check whether a dialog has already been opened in the same script run.
+
+    Only one dialog is supposed to be opened. The check is implemented in a way
+    that for a script run, the open function can only be called once.
+    One dialog at a time is a product decision and not a technical one.
+
+    Raises
+    ------
+    StreamlitAPIException
+        Raised when a dialog has already been opened in the current script run.
+    """
+    script_run_ctx = get_script_run_ctx()
+    # We don't reset the ctx.has_dialog_opened when the flag is False because
+    # it is reset in a new scriptrun anyways. If the execution model ever changes,
+    # this might need to change.
+    if should_open and script_run_ctx:
+        if script_run_ctx.has_dialog_opened:
+            raise StreamlitAPIException(
+                "Only one dialog is allowed to be opened at the same time. Please make sure to not call a dialog-decorated function more than once in a script run."
+            )
+        script_run_ctx.has_dialog_opened = True
+
+
+class Dialog(DeltaGenerator):
+    @staticmethod
+    def _create(
+        parent: DeltaGenerator,
+        title: str,
+        *,
+        dismissible: bool = True,
+        width: DialogWidth = "small",
+    ) -> Dialog:
+        block_proto = BlockProto()
+        block_proto.dialog.title = title
+        block_proto.dialog.dismissible = dismissible
+        block_proto.dialog.width = _process_dialog_width_input(width)
+
+        # We store the delta path here, because in _update we enqueue a new proto
+        # message to update the open status. Without this, the dialog content is gone
+        # when the _update message is sent
+        delta_path: list[int] = (
+            parent._active_dg._cursor.delta_path if parent._active_dg._cursor else []
+        )
+        dialog = cast(Dialog, parent._block(block_proto=block_proto, dg_type=Dialog))
+
+        dialog._delta_path = delta_path
+        dialog._current_proto = block_proto
+        return dialog
+
+    def __init__(
+        self,
+        root_container: int | None,
+        cursor: Cursor | None,
+        parent: DeltaGenerator | None,
+        block_type: str | None,
+    ):
+        super().__init__(root_container, cursor, parent, block_type)
+
+        # Initialized in `_create()`:
+        self._current_proto: BlockProto | None = None
+        self._delta_path: list[int] | None = None
+
+    def _update(self, should_open: bool):
+        """Send an updated proto message to indicate the open-status for the dialog."""
+
+        assert self._current_proto is not None, "Dialog not correctly initialized!"
+        assert self._delta_path is not None, "Dialog not correctly initialized!"
+        _assert_first_dialog_to_be_opened(should_open)
+        msg = ForwardMsg()
+        msg.metadata.delta_path[:] = self._delta_path
+        msg.delta.add_block.CopyFrom(self._current_proto)
+        msg.delta.add_block.dialog.is_open = should_open
+        self._current_proto = msg.delta.add_block
+
+        enqueue_message(msg)
+
+    def open(self) -> None:
+        self._update(True)
+
+    def close(self) -> None:
+        self._update(False)
+
+    def __enter__(self) -> Self:  # type: ignore[override]
+        # This is a little dubious: we're returning a different type than
+        # our superclass' `__enter__` function. Maybe DeltaGenerator.__enter__
+        # should always return `self`?
+        super().__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> Literal[False]:
+        return super().__exit__(exc_type, exc_val, exc_tb)

streamlit/elements/lib/dicttools.py

@@ -0,0 +1,154 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Tools for working with dicts."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+
+
+def _unflatten_single_dict(flat_dict: dict[Any, Any]) -> dict[Any, Any]:
+    """Convert a flat dict of key-value pairs to dict tree.
+
+    Example
+    -------
+
+        _unflatten_single_dict({
+          foo_bar_baz: 123,
+          foo_bar_biz: 456,
+          x_bonks: 'hi',
+        })
+
+        # Returns:
+        # {
+        #   foo: {
+        #     bar: {
+        #       baz: 123,
+        #       biz: 456,
+        #     },
+        #   },
+        #   x: {
+        #     bonks: 'hi'
+        #   }
+        # }
+
+    Parameters
+    ----------
+    flat_dict : dict
+        A one-level dict where keys are fully-qualified paths separated by
+        underscores.
+
+    Returns
+    -------
+    dict
+        A tree made of dicts inside of dicts.
+
+    """
+    out: dict[str, Any] = {}
+    for pathstr, v in flat_dict.items():
+        path = pathstr.split("_")
+
+        prev_dict: dict[str, Any] | None = None
+        curr_dict = out
+
+        for k in path:
+            if k not in curr_dict:
+                curr_dict[k] = {}
+            prev_dict = curr_dict
+            curr_dict = curr_dict[k]
+
+        if prev_dict is not None:
+            prev_dict[k] = v
+
+    return out
+
+
+def unflatten(
+    flat_dict: dict[Any, Any], encodings: set[str] | None = None
+) -> dict[Any, Any]:
+    """Converts a flat dict of key-value pairs to a spec tree.
+
+    Example
+    -------
+        unflatten({
+          foo_bar_baz: 123,
+          foo_bar_biz: 456,
+          x_bonks: 'hi',
+        }, ['x'])
+
+        # Returns:
+        # {
+        #   foo: {
+        #     bar: {
+        #       baz: 123,
+        #       biz: 456,
+        #     },
+        #   },
+        #   encoding: {  # This gets added automatically
+        #     x: {
+        #       bonks: 'hi'
+        #     }
+        #   }
+        # }
+
+    Args
+    ----
+    flat_dict: dict
+        A flat dict where keys are fully-qualified paths separated by
+        underscores.
+
+    encodings: set
+        Key names that should be automatically moved into the 'encoding' key.
+
+    Returns
+    -------
+    A tree made of dicts inside of dicts.
+    """
+    if encodings is None:
+        encodings = set()
+
+    out_dict = _unflatten_single_dict(flat_dict)
+
+    for k, v in list(out_dict.items()):
+        # Unflatten child dicts:
+        if isinstance(v, dict):
+            v = unflatten(v, encodings)
+        elif hasattr(v, "__iter__"):
+            for i, child in enumerate(v):
+                if isinstance(child, dict):
+                    v[i] = unflatten(child, encodings)
+
+        # Move items into 'encoding' if needed:
+        if k in encodings:
+            if "encoding" not in out_dict:
+                out_dict["encoding"] = {}
+            out_dict["encoding"][k] = v
+            out_dict.pop(k)
+
+    return out_dict
+
+
+def remove_none_values(input_dict: Mapping[Any, Any]) -> dict[Any, Any]:
+    """Remove all keys with None values from a dict."""
+    new_dict = {}
+    for key, val in input_dict.items():
+        if isinstance(val, dict):
+            val = remove_none_values(val)
+        if val is not None:
+            new_dict[key] = val
+    return new_dict

streamlit/elements/lib/event_utils.py

@@ -0,0 +1,37 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any
+
+
+class AttributeDictionary(dict[Any, Any]):
+    """
+    A dictionary subclass that supports attribute-style access.
+
+    This class extends the functionality of a standard dictionary to allow items to be accessed
+    via attribute-style dot notation in addition to the traditional key-based access. If a dictionary
+    item is accessed and is itself a dictionary, it is automatically wrapped in another `AttributeDictionary`,
+    enabling recursive attribute-style access.
+    """
+
+    def __getattr__(self, key):
+        try:
+            item = self.__getitem__(key)
+            return AttributeDictionary(item) if isinstance(item, dict) else item
+        except KeyError as err:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{key}'"
+            ) from err
+
+    __setattr__ = dict.__setitem__

streamlit/elements/lib/file_uploader_utils.py

@@ -0,0 +1,66 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from streamlit.errors import StreamlitAPIException
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+TYPE_PAIRS = [
+    (".jpg", ".jpeg"),
+    (".mpg", ".mpeg"),
+    (".mp4", ".mpeg4"),
+    (".tif", ".tiff"),
+    (".htm", ".html"),
+]
+
+
+def normalize_upload_file_type(file_type: str | Sequence[str]) -> Sequence[str]:
+    if isinstance(file_type, str):
+        file_type = [file_type]
+
+    # May need a regex or a library to validate file types are valid
+    # extensions.
+    file_type = [
+        file_type_entry if file_type_entry[0] == "." else f".{file_type_entry}"
+        for file_type_entry in file_type
+    ]
+
+    file_type = [t.lower() for t in file_type]
+
+    for x, y in TYPE_PAIRS:
+        if x in file_type and y not in file_type:
+            file_type.append(y)
+        if y in file_type and x not in file_type:
+            file_type.append(x)
+
+    return file_type
+
+
+def enforce_filename_restriction(filename: str, allowed_types: Sequence[str]) -> None:
+    """Ensure the uploaded file's extension matches the allowed
+    types set by the app developer. In theory, this should never happen, since we
+    enforce file type check by extension on the frontend, but we check it on backend
+    before returning file to the user to protect ourselves.
+    """
+    extension = os.path.splitext(filename)[1].lower()
+    if allowed_types and extension not in allowed_types:
+        raise StreamlitAPIException(
+            f"Invalid file extension: `{extension}`. Allowed: {allowed_types}"
+        )

streamlit/elements/lib/form_utils.py

@@ -0,0 +1,77 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2025)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, NamedTuple
+
+from streamlit import runtime
+from streamlit.delta_generator_singletons import context_dg_stack
+
+if TYPE_CHECKING:
+    from streamlit.delta_generator import DeltaGenerator
+
+
+class FormData(NamedTuple):
+    """Form data stored on a DeltaGenerator."""
+
+    # The form's unique ID.
+    form_id: str
+
+
+def _current_form(this_dg: DeltaGenerator) -> FormData | None:
+    """Find the FormData for the given DeltaGenerator.
+
+    Forms are blocks, and can have other blocks nested inside them.
+    To find the current form, we walk up the dg_stack until we find
+    a DeltaGenerator that has FormData.
+    """
+    if not runtime.exists():
+        return None
+
+    if this_dg._form_data is not None:
+        return this_dg._form_data
+
+    if this_dg == this_dg._main_dg:
+        # We were created via an `st.foo` call.
+        # Walk up the dg_stack to see if we're nested inside a `with st.form` statement.
+        for dg in reversed(context_dg_stack.get()):
+            if dg._form_data is not None:
+                return dg._form_data
+    else:
+        # We were created via an `dg.foo` call.
+        # Take a look at our parent's form data to see if we're nested inside a form.
+        parent = this_dg._parent
+        if parent is not None and parent._form_data is not None:
+            return parent._form_data
+
+    return None
+
+
+def current_form_id(dg: DeltaGenerator) -> str:
+    """Return the form_id for the current form, or the empty string if we're
+    not inside an `st.form` block.
+
+    (We return the empty string, instead of None, because this value is
+    assigned to protobuf message fields, and None is not valid.)
+    """
+    form_data = _current_form(dg)
+    if form_data is None:
+        return ""
+    return form_data.form_id
+
+
+def is_in_form(dg: DeltaGenerator) -> bool:
+    """True if the DeltaGenerator is inside an st.form block."""
+    return current_form_id(dg) != ""