streamlit-nightly 1.53.2.dev20260125__tar.gz → 1.53.2.dev20260128__tar.gz

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamlit-nightly
-Version: 1.53.2.dev20260125
+Version: 1.53.2.dev20260128
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/setup.py

@@ -23,7 +23,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.53.2.dev20260125"  # PEP-440
+VERSION = "1.53.2.dev20260128"  # PEP-440
 
 # IMPORTANT: We should try very hard *not* to add dependencies to Streamlit.
 # And if you do add one, make the required version as general as possible:

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/commands/logo.py

@@ -23,8 +23,10 @@ from streamlit.elements.lib.image_utils import AtomicImage, image_to_url
 from streamlit.elements.lib.layout_utils import LayoutConfig
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+from streamlit.proto.Logo_pb2 import Logo as LogoProto
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner_utils.script_run_context import get_script_run_ctx
+from streamlit.string_util import is_emoji, validate_material_icon
 
 
 def _invalid_logo_text(field_name: str) -> str:
@@ -35,13 +37,59 @@ def _invalid_logo_text(field_name: str) -> str:
     )
 
 
+def _process_logo_image(
+    image: AtomicImage | str, image_id: str
+) -> tuple[LogoProto.ImageType.ValueType, str]:
+    """Detects the image type and prepares the image data for the frontend.
+
+    Parameters
+    ----------
+    image :
+        The image that was provided by the user. Can be an image file,
+        emoji, or material icon string.
+    image_id : str
+        The image ID used when serving local images via the media file manager.
+
+    Returns
+    -------
+    tuple[ImageType, str]
+        The detected image type and the prepared image data.
+
+    Raises
+    ------
+    StreamlitAPIException
+        If the image is an empty string or a plain text string that is not
+        a valid file path, URL, emoji, or material icon.
+    """
+    ImageType = LogoProto.ImageType  # noqa: N806
+
+    # Check if it's a material icon
+    if isinstance(image, str) and image.startswith(":material"):
+        return ImageType.ICON, validate_material_icon(image)
+
+    # Check if it's an emoji
+    if isinstance(image, str) and is_emoji(image):
+        return ImageType.EMOJI, image
+
+    # Otherwise, treat it as an image file
+    image_url = image_to_url(
+        image,
+        layout_config=LayoutConfig(width="content"),
+        clamp=False,
+        channels="RGB",
+        output_format="auto",
+        image_id=image_id,
+    )
+    return ImageType.IMAGE, image_url
+
+
 @gather_metrics("logo")
 def logo(
-    image: AtomicImage,
+    image: AtomicImage | str,
     *,  # keyword-only args:
     size: Literal["small", "medium", "large"] = "medium",
     link: str | None = None,
-    icon_image: AtomicImage | None = None,
+    icon_image: AtomicImage | str | None = None,
 ) -> None:
     r"""
     Renders a logo in the upper-left corner of your app and its sidebar.
@@ -60,12 +108,26 @@ def logo(
 
     Parameters
     ----------
-    image: Anything supported by st.image (except list)
+    image: Anything supported by st.image (except list), emoji, or icon
         The image to display in the upper-left corner of your app and its
-        sidebar. This can be any of the types supported by |st.image|_ except
-        a list. If ``icon_image`` is also provided, then Streamlit will only
+        sidebar. If ``icon_image`` is also provided, then Streamlit will only
         display ``image`` in the sidebar.
 
+        In addition to any of the types supported by |st.image|_ (except list),
+        the following strings are valid:
+
+        - A single-character emoji. For example, you can set ``image="🏠"``
+          or ``image="🚀"``. Emoji short codes are not supported.
+
+        - An icon from the Material Symbols library (rounded style) in the
+          format ``":material/icon_name:"`` where "icon_name" is the name
+          of the icon in snake case.
+
+          For example, ``image=":material/home:"`` will display the
+          Home icon. Find additional icons in the `Material Symbols \
+          <https://fonts.google.com/icons?icon.set=Material+Symbols&icon.style=Rounded>`_
+          font library.
+
         Streamlit scales the image to a max height set by ``size`` and a max
         width to fit within the sidebar.
 
@@ -84,15 +146,19 @@ def logo(
         The external URL to open when a user clicks on the logo. The URL must
         start with "\http://" or "\https://". If ``link`` is ``None`` (default),
         the logo will not include a hyperlink.
-    icon_image: Anything supported by st.image (except list) or None
+    icon_image: Anything supported by st.image (except list), emoji, icon, or None
         An optional, typically smaller image to replace ``image`` in the
-        upper-left corner when the sidebar is closed. This can be any of the
-        types supported by ``st.image`` except a list. If ``icon_image`` is
+        upper-left corner when the sidebar is closed. If ``icon_image`` is
         ``None`` (default), Streamlit will always display ``image`` in the
         upper-left corner, regardless of whether the sidebar is open or closed.
         Otherwise, Streamlit will render ``icon_image`` in the upper-left
         corner of the app when the sidebar is closed.
 
+        In addition to any of the types supported by ``st.image`` (except list),
+        this also accepts single-character emojis (e.g., ``"🏠"``) and Material
+        icons (e.g., ``":material/home:"``). See the ``image`` parameter for
+        more details on these formats.
+
         Streamlit scales the image to a max height set by ``size`` and a max
         width to fit within the sidebar. If the sidebar is closed, the max
         width is retained from when it was last open.
@@ -143,15 +209,9 @@ def logo(
     fwd_msg = ForwardMsg()
 
     try:
-        image_url = image_to_url(
-            image,
-            layout_config=LayoutConfig(width="content"),
-            clamp=False,
-            channels="RGB",
-            output_format="auto",
-            image_id="logo",
-        )
-        fwd_msg.logo.image = image_url
+        image_type, image_value = _process_logo_image(image, "logo")
+        fwd_msg.logo.image = image_value
+        fwd_msg.logo.image_type = image_type
     except Exception as ex:
         raise StreamlitAPIException(_invalid_logo_text("image")) from ex
 
@@ -167,15 +227,11 @@ def logo(
 
     if icon_image:
         try:
-            icon_image_url = image_to_url(
-                icon_image,
-                layout_config=LayoutConfig(width="content"),
-                clamp=False,
-                channels="RGB",
-                output_format="auto",
-                image_id="icon-image",
+            icon_image_type, icon_image_value = _process_logo_image(
+                icon_image, "icon-image"
             )
-            fwd_msg.logo.icon_image = icon_image_url
+            fwd_msg.logo.icon_image = icon_image_value
+            fwd_msg.logo.icon_image_type = icon_image_type
         except Exception as ex:
             raise StreamlitAPIException(_invalid_logo_text("icon_image")) from ex
 

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/config.py

@@ -617,6 +617,17 @@ _create_option(
     scriptable=True,
 )
 
+_create_option(
+    "client.showErrorLinks",
+    description="""
+        Controls whether to show external help links (Google, ChatGPT) in
+        error displays. Can be "auto" (shows on localhost only), true (always
+        show), or false (never show).
+    """,
+    default_val="auto",
+    type_=str,
+)
+
 # Config Section: Runner #
 
 _create_section("runner", "Settings for how Streamlit executes your script")

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/deprecation_util.py

@@ -21,12 +21,17 @@ from typing import Any, Final, TypeVar, cast
 import streamlit
 from streamlit import config
 from streamlit.logger import get_logger
+from streamlit.util import calc_md5
 
 _LOGGER: Final = get_logger(__name__)
 
 TFunc = TypeVar("TFunc", bound=Callable[..., Any])
 TObj = TypeVar("TObj", bound=object)
 
+# Set to track which deprecation warnings have been shown (by message hash)
+# when show_once=True is used
+_shown_warnings: set[str] = set()
+
 
 def _error_details_in_browser_enabled() -> bool:
     """True if we should print deprecation warnings to the browser.
@@ -42,7 +47,9 @@ def _error_details_in_browser_enabled() -> bool:
     )
 
 
-def show_deprecation_warning(message: str, show_in_browser: bool = True) -> None:
+def show_deprecation_warning(
+    message: str, show_in_browser: bool = True, show_once: bool = False
+) -> None:
     """Show a deprecation warning message.
 
     Parameters
@@ -55,7 +62,18 @@ def show_deprecation_warning(message: str, show_in_browser: bool = True) -> None
         set `client.showErrorDetails` to "full" or the legacy True value. All
         other values ("stacktrace", "type", "none", False) will hide deprecation
         warnings in the browser (but still log them to the console).
+    show_once : bool, default=False
+        If True, the warning will only be shown once per unique message (based on
+        message hash). Subsequent calls with the same message will be skipped.
+        This is useful for warnings that may be triggered many times during a
+        script run.
     """
+    if show_once:
+        message_hash = calc_md5(message)
+        if message_hash in _shown_warnings:
+            return
+        _shown_warnings.add(message_hash)
+
     if _error_details_in_browser_enabled() and show_in_browser:
         streamlit.warning(message)
 

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/elements/arrow.py

@@ -983,7 +983,8 @@ class ArrowMixin:
             " If you have a specific use-case that requires the `add_rows` "
             "functionality, please tell us via this "
             "[issue on Github](https://github.com/streamlit/streamlit/issues/13063).",
-            show_in_browser=False,
+            show_in_browser=True,
+            show_once=True,
         )
 
         return _arrow_add_rows(self.dg, data, **kwargs)

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/elements/lib/built_in_chart_utils.py

@@ -862,9 +862,9 @@ def _maybe_melt(
         color_column = _MELTED_COLOR_COLUMN_NAME
 
         columns_to_leave_alone = [x_column]
-        if size_column:
+        if size_column and size_column not in columns_to_leave_alone:
             columns_to_leave_alone.append(size_column)
-        if sort_column:
+        if sort_column and sort_column not in columns_to_leave_alone:
             columns_to_leave_alone.append(sort_column)
 
         df = _melt_data(

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/elements/lib/options_selector_utils.py

@@ -297,6 +297,7 @@ def validate_and_sync_value_with_options(
     This function has a side-effect: if the value is not found in the options
     and a key is provided, it will update session state with the new value.
 
+
     Parameters
     ----------
     current_value
@@ -321,29 +322,16 @@ def validate_and_sync_value_with_options(
     if current_value is None:
         return current_value, False
 
-    # For Enum values, use the original index_() approach which uses == comparison.
-    # This correctly handles enum class identity - enums from different classes
-    # (e.g., after script rerun) should NOT be considered equal, which is important
-    # for enum coercion to work correctly when coercion is disabled.
-    if isinstance(current_value, Enum):
-        try:
-            index_(opt, current_value)
-            return current_value, False
-        except ValueError:
-            pass  # Fall through to reset logic below
-    else:
-        # For non-Enum values, use format_func comparison. This handles custom objects
-        # without __eq__ where widget values are deepcopied and the deepcopied instances
-        # would fail identity comparison with ==.
-        try:
-            formatted_value = format_func(current_value)
-        except Exception:
-            # format_func failed - value is invalid
-            formatted_value = None
-
-        formatted_options_set = {format_func(o) for o in opt}
-        if formatted_value is not None and formatted_value in formatted_options_set:
+    # Use format_func comparison for all values. This correctly handles:
+    # - Custom objects without __eq__ (deepcopied instances)
+    # - Enum values (already from current class due to serde deserialization)
+    formatted_options_set = {format_func(o) for o in opt}
+    try:
+        formatted_value = format_func(current_value)
+        if formatted_value in formatted_options_set:
             return current_value, False
+    except Exception:  # noqa: S110
+        pass  # format_func failed - value is invalid, fall through to reset
 
     # Value not in options - reset to default
     if default_index is not None and len(opt) > 0:
@@ -424,3 +412,65 @@ def validate_and_sync_multiselect_value_with_options(
         get_session_state().reset_state_value(str(key), valid_values)
 
     return valid_values, True
+
+
+def validate_and_sync_range_value_with_options(
+    current_value: tuple[T, T],
+    opt: Sequence[T],
+    default_indices: list[int],
+    key: str | int | None,
+    format_func: Callable[[Any], str] = str,
+) -> tuple[tuple[T, T], bool]:
+    """Validate a range value (tuple of two values) against options.
+
+    If either value in the range is not found in options, the entire range is
+    reset to the default. This function has a side-effect: if the values are
+    invalid and a key is provided, it will update session state with the new value.
+
+    Parameters
+    ----------
+    current_value
+        The current range value (tuple of two values) to validate.
+    opt
+        The sequence of valid options.
+    default_indices
+        The default indices to reset to if value is invalid. Should contain
+        at least one index; if only one index is provided, the second default
+        will be the last option.
+    key
+        The widget key for session state updates.
+    format_func
+        Function to format options for comparison. Used to compare values by their
+        string representation instead of using == directly.
+
+    Returns
+    -------
+    tuple[tuple[T, T], bool]
+        A tuple of (validated_value, value_was_reset).
+    """
+    if len(opt) == 0:
+        return current_value, False
+
+    formatted_options_set = {format_func(o) for o in opt}
+
+    def is_valid(val: Any) -> bool:
+        """Check if a value exists in options via format_func comparison."""
+        try:
+            return format_func(val) in formatted_options_set
+        except Exception:
+            return False
+
+    def get_default_range() -> tuple[T, T]:
+        """Get the default range value."""
+        end_idx = default_indices[1] if len(default_indices) > 1 else len(opt) - 1
+        return (opt[default_indices[0]], opt[end_idx])
+
+    # Validate both values in the range.
+    if is_valid(current_value[0]) and is_valid(current_value[1]):
+        return current_value, False
+
+    # Either value is invalid - reset entire range.
+    new_value = get_default_range()
+    if key is not None:
+        get_session_state().reset_state_value(str(key), new_value)
+    return new_value, True

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/elements/widgets/select_slider.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from dataclasses import dataclass
 from textwrap import dedent
 from typing import (
     TYPE_CHECKING,
@@ -30,9 +29,12 @@ from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.elements.lib.form_utils import current_form_id
 from streamlit.elements.lib.layout_utils import LayoutConfig, validate_width
 from streamlit.elements.lib.options_selector_utils import (
+    create_mappings,
     index_,
     maybe_coerce_enum,
     maybe_coerce_enum_sequence,
+    validate_and_sync_range_value_with_options,
+    validate_and_sync_value_with_options,
 )
 from streamlit.elements.lib.policies import (
     check_widget_policies,
@@ -72,37 +74,79 @@ def _is_range_value(value: T | Sequence[T]) -> TypeGuard[Sequence[T]]:
     return isinstance(value, (list, tuple))
 
 
-@dataclass
 class SelectSliderSerde(Generic[T]):
-    options: Sequence[T]
-    value: list[int]
-    is_range_value: bool
+    """Serializer/deserializer for select_slider widget values.
 
-    def serialize(self, v: object) -> list[int]:
-        return self._as_index_list(v)
+    Uses formatted option strings for robust handling of dynamic option changes.
+    """
 
-    def deserialize(self, ui_value: list[int] | None) -> T | tuple[T, T]:
-        if not ui_value:
-            # Widget has not been used; fallback to the original value,
-            ui_value = self.value
+    def __init__(
+        self,
+        options: Sequence[T],
+        *,
+        formatted_option_to_index: dict[str, int],
+        default_indices: list[int],
+        format_func: Callable[[Any], str] = str,
+    ) -> None:
+        self.options = options
+        self.formatted_option_to_index = formatted_option_to_index
+        self.default_indices = default_indices
+        self.format_func = format_func
+
+    def _get_default(self, is_range: bool) -> T | tuple[T, T]:
+        """Return the default value based on default_indices."""
+        if is_range or len(self.default_indices) >= 2:
+            end_idx = (
+                self.default_indices[1]
+                if len(self.default_indices) > 1
+                else len(self.options) - 1
+            )
+            return (self.options[self.default_indices[0]], self.options[end_idx])
+        return self.options[self.default_indices[0]]
 
-        # The widget always returns floats, so convert to ints before indexing
-        return_value: tuple[T, T] = cast(
-            "tuple[T, T]",
-            tuple(self.options[int(x)] for x in ui_value),
-        )
+    def serialize(self, v: T | tuple[T, T] | list[T]) -> list[str]:
+        """Convert option value(s) to formatted string list."""
+        # Check if v is a single option (handles options that are tuples/lists)
+        try:
+            formatted = self.format_func(v)
+            if formatted in self.formatted_option_to_index:
+                return [formatted]
+        except Exception:  # noqa: S110
+            pass
 
-        # If the original value was a list/tuple, so will be the output (and vice versa)
-        return return_value if self.is_range_value else return_value[0]
+        # Handle as range/sequence
+        if isinstance(v, (tuple, list)):
+            return [self.format_func(x) for x in v]
 
-    def _as_index_list(self, v: Any) -> list[int]:
-        if _is_range_value(v):
-            slider_value = [index_(self.options, val) for val in v]
-            start, end = slider_value
-            if start > end:
-                slider_value = [end, start]
-            return slider_value
-        return [index_(self.options, v)]
+        return [self.format_func(v)]
+
+    def deserialize(self, ui_value: list[str] | None) -> T | tuple[T, T]:
+        """Convert formatted string list back to option value(s)."""
+        is_range = ui_value is not None and len(ui_value) >= 2
+
+        if not ui_value:
+            return self._get_default(is_range=len(self.default_indices) >= 2)
+
+        # Look up each string value
+        results: list[tuple[int, T]] = []
+        for i, s in enumerate(ui_value):
+            idx = self.formatted_option_to_index.get(s)
+            if idx is not None and idx < len(self.options):
+                results.append((idx, self.options[idx]))
+            else:
+                # Fallback to default for this position
+                default_idx = self.default_indices[
+                    min(i, len(self.default_indices) - 1)
+                ]
+                results.append((default_idx, self.options[default_idx]))
+
+        if is_range and len(results) >= 2:
+            # Ensure start <= end by returning deserialized range value in ascending order
+            if results[0][0] > results[1][0]:
+                return (results[1][1], results[0][1])
+            return (results[0][1], results[1][1])
+
+        return results[0][1]
 
 
 class SelectSliderMixin:
@@ -378,16 +422,18 @@ class SelectSliderMixin:
         # Convert element to index of the elements
         slider_value = as_index_list(value)
 
+        # Create formatted options and mapping for string-based storage
+        formatted_options, formatted_option_to_option_index = create_mappings(
+            opt, format_func
+        )
+
         element_id = compute_and_register_element_id(
             "select_slider",
             user_key=key,
-            # Treat the provided key as the main identity; only include
-            # changes to the options (and implicitly their formatting) in the
-            # identity computation as those can invalidate the current value.
-            key_as_main_identity={"options", "format_func"},
+            key_as_main_identity=True,
             dg=self.dg,
             label=label,
-            options=[str(format_func(option)) for option in opt],
+            options=formatted_options,
             value=slider_value,
             help=help,
             width=width,
@@ -403,7 +449,7 @@ class SelectSliderMixin:
         slider_proto.max = len(opt) - 1
         slider_proto.step = 1  # default for index changes
         slider_proto.data_type = SliderProto.INT
-        slider_proto.options[:] = [str(format_func(option)) for option in opt]
+        slider_proto.options[:] = formatted_options
         slider_proto.form_id = current_form_id(self.dg)
         slider_proto.disabled = disabled
         slider_proto.label_visibility.value = get_label_visibility_proto_value(
@@ -415,7 +461,12 @@ class SelectSliderMixin:
         validate_width(width)
         layout_config = LayoutConfig(width=width)
 
-        serde = SelectSliderSerde(opt, slider_value, _is_range_value(value))
+        serde = SelectSliderSerde(
+            opt,
+            formatted_option_to_index=formatted_option_to_option_index,
+            default_indices=slider_value,
+            format_func=format_func,
+        )
 
         widget_state = register_widget(
             slider_proto.id,
@@ -425,7 +476,7 @@ class SelectSliderMixin:
             deserializer=serde.deserialize,
             serializer=serde.serialize,
             ctx=ctx,
-            value_type="double_array_value",
+            value_type="string_array_value",
         )
         if isinstance(widget_state.value, tuple):
             widget_state = maybe_coerce_enum_sequence(
@@ -434,15 +485,50 @@ class SelectSliderMixin:
         else:
             widget_state = maybe_coerce_enum(widget_state, options, opt)
 
-        if widget_state.value_changed:
-            slider_proto.value[:] = serde.serialize(widget_state.value)
+        # Validate the current value against the new options.
+        # If the value is no longer valid (not in options), reset to default.
+        # This handles the case where options change dynamically and the
+        # previously selected value is no longer available.
+        # Determine if we're dealing with a range value based on the actual
+        # widget state value, not just the value parameter (range can come from
+        # session state even when value param is None).
+        actual_is_range = isinstance(widget_state.value, tuple)
+        if actual_is_range:
+            # Range value: validate using range-specific function.
+            range_value = cast("tuple[T, T]", widget_state.value)
+            validated_range, value_needs_reset = (
+                validate_and_sync_range_value_with_options(
+                    range_value,
+                    opt,
+                    slider_value,
+                    key,
+                    format_func,
+                )
+            )
+            current_value: T | tuple[T, T] = validated_range
+        else:
+            # Single value: use the standard validation function.
+            validated_single, value_needs_reset = validate_and_sync_value_with_options(
+                widget_state.value,
+                opt,
+                slider_value[0],
+                key,
+                format_func,
+            )
+            # validated_single is guaranteed to be T (not None) because
+            # deserialize() always returns a default value, never None.
+            current_value = cast("T", validated_single)
+
+        if value_needs_reset or widget_state.value_changed:
+            serialized_value = serde.serialize(current_value)
+            slider_proto.raw_value[:] = serialized_value
             slider_proto.set_value = True
 
         if ctx:
             save_for_app_testing(ctx, element_id, format_func)
 
         self.dg._enqueue("slider", slider_proto, layout_config=layout_config)
-        return widget_state.value
+        return current_value
 
     @property
     def dg(self) -> DeltaGenerator:

{streamlit_nightly-1.53.2.dev20260125 → streamlit_nightly-1.53.2.dev20260128}/streamlit/hello/plotting_demo.py

@@ -23,16 +23,24 @@ from streamlit.hello.utils import show_code
 def plotting_demo() -> None:
     progress_bar = st.sidebar.progress(0)
     status_text = st.sidebar.empty()
-    last_rows = np.random.randn(1, 1)  # noqa: NPY002
-    chart = st.line_chart(last_rows)
-
-    for i in range(1, 101):
-        new_rows = last_rows[-1, :] + np.random.randn(5, 1).cumsum(axis=0)  # noqa: NPY002
-        status_text.text(f"{i}% complete")
-        chart.add_rows(new_rows)
-        progress_bar.progress(i)
-        last_rows = new_rows
-        time.sleep(0.05)
+    chart = st.empty()
+
+    # Initialize with one data point
+    data = np.random.randn(1, 1)  # noqa: NPY002
+    chart.line_chart(data)
+
+    for i in range(1, 51):
+        # Generate new rows based on the last value (random walk)
+        new_rows = data[-1, :] + np.random.randn(5, 1).cumsum(axis=0)  # noqa: NPY002
+        # Append new rows to existing data
+        data = np.concatenate([data, new_rows])
+        # Update the chart with full data
+        chart.line_chart(data)
+        # Scale progress to show 0-100% with 50 iterations
+        progress = i * 2
+        status_text.text(f"{progress}% complete")
+        progress_bar.progress(progress)
+        time.sleep(0.01)
 
     progress_bar.empty()
 
@@ -47,8 +55,7 @@ st.title("Plotting demo")
 st.write(
     """
     This demo illustrates a combination of plotting and animation with
-    Streamlit. We're generating a bunch of random numbers in a loop for around
-    5 seconds. Enjoy!
+    Streamlit. We're generating a bunch of random numbers in a loop. Enjoy!
     """
 )
 plotting_demo()