streamlit-nightly 1.42.3.dev20250301__py2.py3-none-any.whl → 1.43.1.dev20250306__py2.py3-none-any.whl

streamlit/commands/navigation.py

@@ -88,132 +88,172 @@ def navigation(
     """
     Configure the available pages in a multipage app.
 
-    Call ``st.navigation`` in your entrypoint file to define the structure and navigation
-    of your multipage application. The function accepts pages defined as file paths,
-    callable functions, or StreamlitPage objects. It returns the current page, which
-    can be executed using the ``.run()`` method.
-
-    When using ``st.navigation``, your entrypoint file acts as a router or frame
-    containing common elements for all pages. Streamlit executes the entrypoint file
-    with every app rerun. To execute the current page, call the ``.run()`` method on
+    Call ``st.navigation`` in your entrypoint file to define the available
+    pages for your app. ``st.navigation`` returns the current page, which can
+    be executed using ``.run()`` method.
+
+    When using ``st.navigation``, your entrypoint file (the file passed to
+    ``streamlit run``) acts like a router or frame of common elements around
+    each of your pages. Streamlit executes the entrypoint file with every app
+    rerun. To execute the current page, you must call the ``.run()`` method on
     the ``StreamlitPage`` object returned by ``st.navigation``.
 
-    The set of available pages can be dynamically updated with each rerun.
-    By default, the navigation menu appears in the sidebar if there is more than
-    one page. This behavior can be modified using the ``position`` parameter.
+    The set of available pages can be updated with each rerun for dynamic
+    navigation. By default, ``st.navigation`` displays the available pages in
+    the sidebar if there is more than one page. This behavior can be changed
+    using the ``position`` keyword argument.
 
-    Note: When any session of your app executes ``st.navigation``, the app will
-    ignore the ``pages/`` directory across all sessions.
+    As soon as any session of your app executes the ``st.navigation`` command,
+    your app will ignore the ``pages/`` directory (across all sessions).
 
     Parameters
     ----------
-    pages : Union[List[Union[str, Path, Callable, StreamlitPage]], Dict[str, List[Union[str, Path, Callable, StreamlitPage]]]]
-        The available pages for the app. Can be specified in several ways:
-
-        As a list:
-        - List of file paths as strings or Path objects (e.g., ["page1.py", Path("page2.py")])
-        - List of callable functions (e.g., [page1_func, page2_func])
-        - List of StreamlitPage objects (e.g., [st.Page("page1.py"), st.Page(page2_func)])
-        - Mixed list of the above types
-
-        As a dictionary for grouped sections:
-        - Keys are section labels
-        - Values are lists containing any combination of the above types
-
-        Example dictionary:
-        {
-            "Section 1": ["page1.py", Path("page2.py"), page3_func],
-            "Section 2": [st.Page("page3.py")]
-        }
+    pages : list[page-like], dict[str, list[page-like]]
+        The available pages for the app.
+
+        To create a navigation menu with no sections or page groupings,
+        ``pages`` must be a list of page-like objects. Page-like objects are
+        anything that can be passed to ``st.Page`` or a ``StreamlitPage``
+        object returned by ``st.Page``.
+
+        To create labeled sections or page groupings within the navigation
+        menu, ``pages`` must be a dictionary. Each key is the label of a
+        section and each value is the list of page-like objects for
+        that section.
+
+        When you use a string or path as a page-like object, they are
+        internally passed to ``st.Page`` and converted to ``StreamlitPage``
+        objects. In this case, the page will have the default title, icon, and
+        path inferred from its path or filename. To customize these attributes
+        for your page, initialize your page with ``st.Page``.
+
+    position : "sidebar" or "hidden"
+        The position of the navigation menu. If this is ``"sidebar"``
+        (default), the navigation widget appears at the top of the sidebar. If
+        this is ``"hidden"``, the navigation widget is not displayed.
 
-    position : Literal["sidebar", "hidden"]
-        Controls the navigation menu position:
-        - "sidebar" (default): Places the navigation at the top of the sidebar
-        - "hidden": Hides the navigation widget
-        Note: Navigation is always hidden when there's only one page.
+        If there is only one page in ``pages``, the navigation will be hidden
+        for any value of ``position``.
 
     expanded : bool
-        Controls the navigation menu's expansion state:
-        - False (default): Menu starts collapsed with a "more" button
-        - True: Menu stays permanently expanded
-        Note: When changing from True to False, the menu remains expanded
-        but displays a collapse button.
+        Whether the navigation menu should be expanded. If this is ``False``
+        (default), the navigation menu will be collapsed and will include a
+        button to view more options when there are too many pages to display.
+        If this is ``True``, the navigation menu will always be expanded; no
+        button to collapse the menu will be displayed.
+
+        If ``st.navigation`` changes from ``expanded=True`` to
+        ``expanded=False`` on a rerun, the menu will stay expanded and a
+        collapse button will be displayed.
 
     Returns
     -------
     StreamlitPage
-        The currently selected page object that can be executed with .run()
+        The current page selected by the user. To run the page, you must use
+        the ``.run()`` method on it.
 
     Examples
     --------
-    Basic usage with file paths:
+    The following examples show different possible entrypoint files, each named
+    ``streamlit_app.py``. An entrypoint file is passed to ``streamlit run``. It
+    manages your app's navigation and serves as a router between pages.
+
+    **Example 1: Use a callable or Python file as a page**
+
+    You can declare pages from callables or file paths. If you pass callables
+    or paths to ``st.navigation`` as a page-like objects, they are internally
+    converted to ``StreamlitPage`` objects using ``st.Page``. In this case, the
+    page titles, icons, and paths are inferred from the file or callable names.
+
+    ``page_1.py`` (in the same directory as your entrypoint file):
+
+    >>> import streamlit as st
+    >>>
+    >>> st.title("Page 1")
+
+    ``streamlit_app.py``:
+
     >>> import streamlit as st
-    >>> pages = ["home.py", "about.py", "contact.py"]
-    >>> page = st.navigation(pages)
-    >>> page.run()
-
-    Using functions as pages:
-    >>> def home():
-    ...     st.title("Home")
-    >>> def about():
-    ...     st.title("About")
     >>>
-    >>> pages = [home, about]
-    >>> page = st.navigation(pages)
-    >>> page.run()
+    >>> def page_2():
+    ...     st.title("Page 2")
+    >>>
+    >>> pg = st.navigation(["page_1.py", page_2])
+    >>> pg.run()
+
+    .. output::
+        https://doc-navigation-example-1.streamlit.app/
+        height: 200px
+
+    **Example 2: Group pages into sections and customize them with ``st.Page``**
 
-    Mixed usage with sections:
+    You can use a dictionary to create sections within your navigation menu. In
+    the following example, each page is similar to Page 1 in Example 1, and all
+    pages are in the same directory. However, you can use Python files from
+    anywhere in your repository. ``st.Page`` is used to give each page a custom
+    title. For more information, see |st.Page|_.
+
+    Directory structure:
+
+    >>> your_repository/
+    >>> ├── create_account.py
+    >>> ├── learn.py
+    >>> ├── manage_account.py
+    >>> ├── streamlit_app.py
+    >>> └── trial.py
+
+    ``streamlit_app.py``:
+
+    >>> import streamlit as st
+    >>>
     >>> pages = {
-    ...     "Main": ["home.py", about_func],Page
-    ...     "Info": [st.Page("help.py", title="Help Center")],
+    ...     "Your account": [
+    ...         st.Page("create_account.py", title="Create your account"),
+    ...         st.Page("manage_account.py", title="Manage your account"),
+    ...     ],
+    ...     "Resources": [
+    ...         st.Page("learn.py", title="Learn about us"),
+    ...         st.Page("trial.py", title="Try it out"),
+    ...     ],
     ... }
-    >>> page = st.navigation(pages)
-    >>> page.run()
+    >>>
+    >>> pg = st.navigation(pages)
+    >>> pg.run()
+
+    .. output::
+        https://doc-navigation-example-2.streamlit.app/
+        height: 300px
+
+    **Example 3: Stateful widgets across multiple pages**
 
-    Stateful widgets across pages:
+    Call widget functions in your entrypoint file when you want a widget to be
+    stateful across pages. Assign keys to your common widgets and access their
+    values through Session State within your pages.
+
+    ``streamlit_app.py``:
+
+    >>> import streamlit as st
+    >>>
     >>> def page1():
-    ...     st.write(st.session_state.user_name)
+    >>>     st.write(st.session_state.foo)
+    >>>
     >>> def page2():
-    ...     st.write(st.session_state.user_email)
+    >>>     st.write(st.session_state.bar)
     >>>
-    >>> # Common widgets in entrypoint
-    >>> st.text_input("Name", key="user_name")
-    >>> st.text_input("Email", key="user_email")
+    >>> # Widgets shared by all the pages
+    >>> st.sidebar.selectbox("Foo", ["A", "B", "C"], key="foo")
+    >>> st.sidebar.checkbox("Bar", key="bar")
     >>>
-    >>> page = st.navigation([page1, page2])
-    >>> page.run()
+    >>> pg = st.navigation([page1, page2])
+    >>> pg.run()
 
-    Using Path objects:
-    >>> from pathlib import Path
-    >>> pages = [Path("home.py"), Path("about.py")]
-    >>> page = st.navigation(pages)
-    >>> page.run()
+    .. output::
+        https://doc-navigation-multipage-widgets.streamlit.app/
+        height: 350px
+
+    .. |st.Page| replace:: ``st.Page``
+    .. _st.Page: https://docs.streamlit.io/develop/api-reference/navigation/st.page
 
-    Mixed usage with Path and sections:
-    >>> pages = {
-    ...     "Main": [Path("home.py"), about_func],
-    ...     "Info": [st.Page(Path("help.py"), title="Help Center")],
-    ... }
-    >>> page = st.navigation(pages)
-    >>> page.run()
-
-    Raises
-    ------
-    StreamlitAPIException
-        In the following cases:
-        - No pages provided
-        - Multiple pages set as default
-        - Duplicate URL pathnames
-        - Invalid page type provided
-
-    Notes
-    -----
-    - File paths can be relative or absolute
-    - Function names are used as default page titles
-    - URL pathnames must be unique across all pages
-    - Only one page can be set as default
-    - The first page is automatically set as default if none specified
-    - Common widgets should be defined in the entrypoint file for state sharing
     """
     # Disable the use of the pages feature (ie disregard v1 behavior of Multipage Apps)
     PagesManager.uses_pages_directory = False

streamlit/components/v1/component_arrow.py

@@ -135,5 +135,7 @@ def arrow_proto_to_dataframe(proto: ArrowTableProto) -> DataFrame:
     columns = dataframe_util.convert_arrow_bytes_to_pandas_df(proto.columns)
 
     return pd.DataFrame(
-        data.values, index=index.values.T.tolist(), columns=columns.values.T.tolist()
+        data.to_numpy(),
+        index=index.to_numpy().T.tolist(),
+        columns=columns.to_numpy().T.tolist(),
     )

streamlit/config.py

@@ -469,22 +469,35 @@ def _logger_message_format() -> str:
         return "%(asctime)s %(message)s"
 
 
-_create_option(
+@_create_option(
     "logger.enableRich",
-    description="""
-        Controls whether uncaught app exceptions are logged via the rich library.
-
-        If True and if rich is installed, exception tracebacks will be logged with
-        syntax highlighting and formatting. Rich tracebacks are easier to read and
-        show more code than standard Python tracebacks.
-
-        If set to False, the default Python traceback formatting will be used.
-    """,
-    default_val=False,
     visibility="hidden",
     type_=bool,
     scriptable=True,
 )
+def _logger_enable_rich() -> bool:
+    """
+    Controls whether uncaught app exceptions are logged via the rich library.
+
+    If True and if rich is installed, exception tracebacks will be logged with
+    syntax highlighting and formatting. Rich tracebacks are easier to read and
+    show more code than standard Python tracebacks.
+
+    If set to False, the default Python traceback formatting will be used.
+
+    Defaults to True if rich is installed, False otherwise.
+    """
+    try:
+        import rich  # noqa: F401
+
+        # Rich is importable, activate rich logging.
+        return True
+    except Exception:
+        # We are extra broad in catching exceptions here because we don't want
+        # that this causes Streamlit to crash if there is any unexpected
+        # exception thrown by the import
+        return False
+
 
 # Config Section: Client #
 
@@ -1089,6 +1102,15 @@ _create_option(
     visibility="hidden",
 )
 
+_create_option(
+    "theme.showSidebarSeparator",
+    description="""
+        Whether to show a vertical separator between the sidebar and the main content.
+    """,
+    type_=bool,
+    visibility="hidden",
+)
+
 # Config Section: Secrets #
 
 _create_section("secrets", "Secrets configuration.")

streamlit/dataframe_util.py

@@ -67,9 +67,14 @@ _MAX_UNEVALUATED_DF_ROWS = 10000
 
 _PANDAS_DATA_OBJECT_TYPE_RE: Final = re.compile(r"^pandas.*$")
 
-_DASK_DATAFRAME: Final = "dask.dataframe.core.DataFrame"
-_DASK_INDEX: Final = "dask.dataframe.core.Index"
-_DASK_SERIES: Final = "dask.dataframe.core.Series"
+_DASK_DATAFRAME: Final = "dask.dataframe.dask_expr._collection.DataFrame"
+_DASK_SERIES: Final = "dask.dataframe.dask_expr._collection.Series"
+_DASK_INDEX: Final = "dask.dataframe.dask_expr._collection.Index"
+# Dask removed the old legacy types, to support older and newer versions
+# we are still supporting the old an new types.
+_DASK_DATAFRAME_LEGACY: Final = "dask.dataframe.core.DataFrame"
+_DASK_SERIES_LEGACY: Final = "dask.dataframe.core.Series"
+_DASK_INDEX_LEGACY: Final = "dask.dataframe.core.Index"
 _DUCKDB_RELATION: Final = "duckdb.duckdb.DuckDBPyRelation"
 _MODIN_DF_TYPE_STR: Final = "modin.pandas.dataframe.DataFrame"
 _MODIN_SERIES_TYPE_STR: Final = "modin.pandas.series.Series"
@@ -377,8 +382,11 @@ def is_dask_object(obj: object) -> bool:
     """True if obj is a Dask DataFrame, Series, or Index."""
     return (
         is_type(obj, _DASK_DATAFRAME)
+        or is_type(obj, _DASK_DATAFRAME_LEGACY)
         or is_type(obj, _DASK_SERIES)
+        or is_type(obj, _DASK_SERIES_LEGACY)
         or is_type(obj, _DASK_INDEX)
+        or is_type(obj, _DASK_INDEX_LEGACY)
     )
 
 
@@ -498,7 +506,7 @@ def _fix_column_naming(data_df: DataFrame) -> DataFrame:
         # Pandas automatically names the first column with 0 if it is not named.
         # We rename it to "value" to make it more descriptive if there is only
         # one column in the dataframe.
-        data_df.rename(columns={0: "value"}, inplace=True)
+        data_df = data_df.rename(columns={0: "value"})
     return data_df
 
 

streamlit/elements/lib/built_in_chart_utils.py

@@ -567,7 +567,7 @@ def _maybe_reset_index_in_place(
             x_column = df.index.name
 
         df.index.name = x_column
-        df.reset_index(inplace=True)
+        df.reset_index(inplace=True)  # noqa: PD002
 
     return x_column
 
@@ -598,7 +598,7 @@ def _maybe_convert_color_column_in_place(df: pd.DataFrame, color_column: str | N
     if color_column is None or len(df[color_column]) == 0:
         return
 
-    first_color_datum = df[color_column].iat[0]
+    first_color_datum = df[color_column].iloc[0]
 
     if is_hex_color_like(first_color_datum):
         # Hex is already CSS-valid.
@@ -988,7 +988,7 @@ def _get_color_encoding(
 
         # If the 0th element in the color column looks like a color, we'll use the color column's
         # values as the colors in our chart.
-        elif len(df[color_column]) and is_color_like(df[color_column].iat[0]):
+        elif len(df[color_column]) and is_color_like(df[color_column].iloc[0]):
             color_range = [to_css_color(c) for c in df[color_column].unique()]
             color_enc["scale"] = alt.Scale(range=color_range)
             # Don't show the color legend, because it will just show text with the color values,

streamlit/elements/lib/pandas_styler_utils.py

@@ -139,7 +139,7 @@ def _marshall_styles(
         cellstyle = styles["cellstyle"]
         cellstyle = _trim_pandas_styles(cellstyle)
         for style in cellstyle:
-            rule = _pandas_style_to_css("cell_style", style, styler.uuid)
+            rule = _pandas_style_to_css("cell_style", style, styler.uuid, separator="_")
             css_rules.append(rule)
 
     if len(css_rules) > 0:
@@ -168,7 +168,7 @@ def _pandas_style_to_css(
     style_type: str,
     style: Mapping[str, Any],
     uuid: str,
-    separator: str = "",
+    separator: str = "_",
 ) -> str:
     """Convert pandas.Styler translated style to CSS.
 
@@ -189,7 +189,7 @@ def _pandas_style_to_css(
     """
     declarations = []
     for css_property, css_value in style["props"]:
-        declaration = css_property.strip() + ": " + css_value.strip()
+        declaration = str(css_property).strip() + ": " + str(css_value).strip()
         declarations.append(declaration)
 
     table_selector = f"#T_{uuid}"
@@ -269,6 +269,6 @@ def _use_display_values(df: DataFrame, styles: Mapping[str, Any]) -> DataFrame:
                 if "id" in cell:
                     if match := cell_selector_regex.match(cell["id"]):
                         r, c = map(int, match.groups())
-                        new_df.iat[r, c] = str(cell["display_value"])
+                        new_df.iloc[r, c] = str(cell["display_value"])
 
     return new_df

streamlit/elements/map.py

@@ -361,7 +361,7 @@ def _get_lat_or_lon_col_name(
     # (Read about ExtensionArrays here: # https://pandas.pydata.org/community/blog/extension-arrays.html)
     # However, after a performance test I found the solution below runs basically as
     # fast as .values.any().
-    if any(data[col_name].isnull().array):
+    if any(data[col_name].isna().array):
         raise StreamlitAPIException(
             f"Column {col_name} is not allowed to contain null values, such "
             "as NaN, NaT, or None."
@@ -421,7 +421,9 @@ def _convert_color_arg_or_column(
 
     if color_col_name is not None:
         # Convert color column to the right format.
-        if len(data[color_col_name]) > 0 and is_color_like(data[color_col_name].iat[0]):
+        if len(data[color_col_name]) > 0 and is_color_like(
+            data[color_col_name].iloc[0]
+        ):
             # Use .loc[] to avoid a SettingWithCopyWarning in some cases.
             data.loc[:, color_col_name] = data.loc[:, color_col_name].map(
                 to_int_color_tuple

streamlit/elements/media.py

@@ -103,7 +103,8 @@ class MediaMixin:
 
         format : str
             The MIME type for the audio file. This defaults to ``"audio/wav"``.
-            For more information, see https://tools.ietf.org/html/rfc4281.
+            For more information about MIME types, see
+            https://www.iana.org/assignments/media-types/media-types.xhtml.
 
         start_time: int, float, timedelta, str, or None
             The time from which the element should start playing. This can be
@@ -238,7 +239,8 @@ class MediaMixin:
 
         format : str
             The MIME type for the video file. This defaults to ``"video/mp4"``.
-            For more information, see https://tools.ietf.org/html/rfc4281.
+            For more information about MIME types, see
+            https://www.iana.org/assignments/media-types/media-types.xhtml.
 
         start_time: int, float, timedelta, str, or None
             The time from which the element should start playing. This can be

streamlit/elements/widgets/button.py

@@ -307,20 +307,31 @@ class ButtonMixin:
             .. |st.markdown| replace:: ``st.markdown``
             .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown
 
-        data : str or bytes or file
-            The contents of the file to be downloaded. See example below for
-            caching techniques to avoid recomputing this data unnecessarily.
+        data : str, bytes, or file
+            The contents of the file to be downloaded.
+
+            To prevent unncecessary recomputation, use caching when converting
+            your data for download. For more information, see the Example 1
+            below.
 
         file_name: str
             An optional string to use as the name of the file to be downloaded,
-            such as 'my_file.csv'. If not specified, the name will be
+            such as ``"my_file.csv"``. If not specified, the name will be
             automatically generated.
 
         mime : str or None
-            The MIME type of the data. If None, defaults to "text/plain"
-            (if data is of type *str* or is a textual *file*) or
-            "application/octet-stream" (if data is of type *bytes* or is a
-            binary *file*).
+            The MIME type of the data. If this is ``None`` (default), Streamlit
+            sets the MIME type depending on the value of ``data`` as follows:
+
+            - If ``data`` is a string or textual file (i.e. ``str`` or
+              ``io.TextIOWrapper`` object), Streamlit uses the "text/plain"
+              MIME type.
+            - If ``data`` is a binary file or bytes (i.e. ``bytes``,
+              ``io.BytesIO``, ``io.BufferedReader``, or ``io.RawIOBase``
+              object), Streamlit uses the "application/octet-stream" MIME type.
+
+            For more information about MIME types, see
+            https://www.iana.org/assignments/media-types/media-types.xhtml.
 
         key : str or int
             An optional string or integer to use as the unique key for the widget.
@@ -404,45 +415,98 @@ class ButtonMixin:
 
         Examples
         --------
-        Download a large DataFrame as a CSV:
+        **Example 1: Download a dataframe as a CSV file**
+
+        When working with a large dataframe, it's recommended to fetch your
+        data with a cached function. When working with a download button, it's
+        similarly recommended to convert your data into a downloadable format
+        with a cached function. Caching ensures that the app reruns
+        effeciently.
 
         >>> import streamlit as st
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>>
+        >>> @st.cache_data
+        >>> def get_data():
+        >>>     df = pd.DataFrame(
+        ...         np.random.randn(50, 20), columns=("col %d" % i for i in range(20))
+        ...     )
+        >>>     return df
         >>>
         >>> @st.cache_data
-        ... def convert_df(df):
-        ...     # IMPORTANT: Cache the conversion to prevent computation on every rerun
-        ...     return df.to_csv().encode("utf-8")
+        >>> def convert_for_download(df):
+        >>>     return df.to_csv().encode("utf-8")
         >>>
-        >>> csv = convert_df(my_large_df)
+        >>> df = get_data()
+        >>> csv = convert_for_download(df)
         >>>
         >>> st.download_button(
-        ...     label="Download data as CSV",
+        ...     label="Download CSV",
         ...     data=csv,
-        ...     file_name="large_df.csv",
+        ...     file_name="data.csv",
         ...     mime="text/csv",
+        ...     icon=":material/download:",
         ... )
 
-        Download a string as a file:
+        .. output::
+           https://doc-download-button-csv.streamlit.app/
+           height: 200px
 
-        >>> import streamlit as st
-        >>>
-        >>> text_contents = '''This is some text'''
-        >>> st.download_button("Download some text", text_contents)
+        **Example 2: Download a string as a text file**
+
+        If you pass a string to the ``data`` argument, Streamlit will
+        automatically use the "text/plain" MIME type.
+
+        When you have a widget (like a text area) affecting the value of your
+        download, it's recommended to use another button to prepare the
+        download. In this case, use ``on_click="ignore"`` in your download
+        button to prevent the download button from rerunning your app. This
+        turns the download button into a frontend-only element that can be
+        nested in another button.
 
-        Download a binary file:
+        Without a preparation button, a user can type something into the text
+        area and immediately click the download button. Because a download is
+        initiated concurrently with the app rerun, this can create a race-like
+        condition where the user doesn't see the updated data in their
+        download.
+
+        .. important::
+           Even when you prevent your download button from triggering a rerun,
+           another widget with a pending change can still trigger a rerun. For
+           example, if a text area has a pending change when a user clicks a
+           download button, the text area will trigger a rerun.
 
         >>> import streamlit as st
         >>>
-        >>> binary_contents = b"example content"
-        >>> # Defaults to "application/octet-stream"
-        >>> st.download_button("Download binary file", binary_contents)
+        >>> message = st.text_area("Message", value="Lorem ipsum.\nStreamlit is cool.")
+        >>>
+        >>> if st.button("Prepare download"):
+        >>>     st.download_button(
+        ...         label="Download text",
+        ...         data=message,
+        ...         file_name="message.txt",
+        ...         on_click="ignore",
+        ...         type="primary",
+        ...         icon=":material/download:",
+        ...     )
+
+        .. output::
+           https://doc-download-button-text.streamlit.app/
+           height: 250px
 
-        Download an image:
+        **Example 3: Download a file**
+
+        Use a context manager to open and read a local file on your Streamlit
+        server. Pass the ``io.BufferedReader`` object directly to ``data``.
+        Remember to specify the MIME type if you don't want the default
+        type of ``"application/octet-stream"`` for generic binary data. In the
+        example below, the MIME type is set to ``"image/png"`` for a PNG file.
 
         >>> import streamlit as st
         >>>
         >>> with open("flower.png", "rb") as file:
-        ...     btn = st.download_button(
+        ...     st.download_button(
         ...         label="Download image",
         ...         data=file,
         ...         file_name="flower.png",
@@ -450,8 +514,8 @@ class ButtonMixin:
         ...     )
 
         .. output::
-           https://doc-download-buton.streamlit.app/
-           height: 335px
+           https://doc-download-button-file.streamlit.app/
+           height: 200px
 
         """
         ctx = get_script_run_ctx()