streamlit-nightly 1.42.3.dev20250302__tar.gz → 1.43.2.dev20250307__tar.gz

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: streamlit-nightly
-Version: 1.42.3.dev20250302
+Version: 1.43.2.dev20250307
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/setup.py

@@ -21,7 +21,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.42.3.dev20250302"  # PEP-440
+VERSION = "1.43.2.dev20250307"  # 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.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/auth_util.py

@@ -172,8 +172,8 @@ def validate_auth_credentials(provider: str) -> None:
 
     provider_section = auth_section.get(provider)
 
-    # TODO[kajarenc]: Revisit this check later when investigating the ability
-    # TODO[kajarenc] to add "_" to the provider name.
+    # TODO(kajarenc): Revisit this check later when investigating the ability
+    # TODO(kajarenc): to add "_" to the provider name.
     if "_" in provider:
         raise StreamlitAuthError(
             f'Auth provider name "{provider}" contains an underscore. '

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/commands/navigation.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping, Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, Callable, Literal, Union
 
@@ -39,7 +40,7 @@ PageType: TypeAlias = Union[str, Path, Callable[[], None], StreamlitPage]
 
 
 def convert_to_streamlit_page(
-    page_input: str | Path | Callable[[], None] | StreamlitPage,
+    page_input: PageType,
 ) -> StreamlitPage:
     """Convert various input types to StreamlitPage objects."""
     if isinstance(page_input, StreamlitPage):
@@ -80,7 +81,7 @@ def send_page_not_found(ctx: ScriptRunContext):
 
 @gather_metrics("navigation")
 def navigation(
-    pages: list[PageType] | dict[SectionHeader, list[PageType]],
+    pages: Sequence[PageType] | Mapping[SectionHeader, Sequence[PageType]],
     *,
     position: Literal["sidebar", "hidden"] = "sidebar",
     expanded: bool = False,
@@ -88,132 +89,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.
+    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 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
+    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 : Sequence[page-like], Mapping[str, Sequence[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
@@ -222,12 +263,12 @@ def navigation(
 
 
 def _navigation(
-    pages: list[PageType] | dict[SectionHeader, list[PageType]],
+    pages: Sequence[PageType] | Mapping[SectionHeader, Sequence[PageType]],
     *,
     position: Literal["sidebar", "hidden"],
     expanded: bool,
 ) -> StreamlitPage:
-    if isinstance(pages, list):
+    if isinstance(pages, Sequence):
         converted_pages = [convert_to_streamlit_page(p) for p in pages]
         nav_sections = {"": converted_pages}
     else:

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/components/v1/custom_component.py

@@ -118,7 +118,7 @@ And if you're using Streamlit Cloud, add "pyarrow" to your requirements.txt."""
         # In addition to the custom kwargs passed to the component, we also
         # send the special 'default' and 'key' params to the component
         # frontend.
-        all_args = dict(kwargs, **{"default": default, "key": key})
+        all_args = dict(kwargs, default=default, key=key)
 
         json_args = {}
         special_args = []

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/elements/doc_string.py

@@ -270,8 +270,7 @@ def _get_variable_name_from_code_str(code):
     ):
         # A common pattern is to add "," at the end of a magic command to make it print.
         # This removes that final ",", so it looks nicer.
-        if code.endswith(","):
-            code = code[:-1]
+        code = code.removesuffix(",")
 
         return code
 

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/elements/lib/color_util.py

@@ -125,9 +125,7 @@ def _is_cssrgb_color_like(color: MaybeColor) -> bool:
     NOTE: We only accept hex colors and color tuples as user input. So do not use this function to
     validate user input! Instead use is_hex_color_like and is_color_tuple_like.
     """
-    return isinstance(color, str) and (
-        color.startswith("rgb(") or color.startswith("rgba(")
-    )
+    return isinstance(color, str) and color.startswith(("rgb(", "rgba("))
 
 
 def is_color_tuple_like(color: MaybeColor) -> bool:

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/elements/lib/file_uploader_utils.py

@@ -14,8 +14,11 @@
 
 from __future__ import annotations
 
+import os
 from typing import TYPE_CHECKING
 
+from streamlit.errors import StreamlitAPIException
+
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
@@ -48,3 +51,16 @@ def normalize_upload_file_type(file_type: str | Sequence[str]) -> Sequence[str]:
             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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/elements/lib/image_utils.py

@@ -344,7 +344,7 @@ def image_to_url(
 
 
 def _4d_to_list_3d(array: npt.NDArray[Any]) -> list[npt.NDArray[Any]]:
-    return [array[i, :, :, :] for i in range(0, array.shape[0])]
+    return [array[i, :, :, :] for i in range(array.shape[0])]
 
 
 def marshall_images(

{streamlit_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/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_nightly-1.42.3.dev20250302 → streamlit_nightly-1.43.2.dev20250307}/streamlit/elements/markdown.py

@@ -136,44 +136,6 @@ class MarkdownMixin:
 
         return self.dg._enqueue("markdown", markdown_proto)
 
-    @gather_metrics("code")
-    def code(
-        self,
-        body: SupportsStr,
-        language: str | None = "python",
-    ) -> DeltaGenerator:
-        """Display a code block with optional syntax highlighting.
-
-        (This is a convenience wrapper around `st.markdown()`)
-
-        Parameters
-        ----------
-        body : str
-            The string to display as code.
-
-        language : str or None
-            The language that the code is written in, for syntax highlighting.
-            If ``None``, the code will be unstyled. Defaults to ``"python"``.
-
-            For a list of available ``language`` values, see:
-
-            https://github.com/react-syntax-highlighter/react-syntax-highlighter/blob/master/AVAILABLE_LANGUAGES_PRISM.MD
-
-        Example
-        -------
-        >>> import streamlit as st
-        >>>
-        >>> code = '''def hello():
-        ...     print("Hello, Streamlit!")'''
-        >>> st.code(code, language="python")
-
-        """
-        code_proto = MarkdownProto()
-        markdown = f"```{language or ''}\n{body}\n```"
-        code_proto.body = clean_text(markdown)
-        code_proto.element_type = MarkdownProto.Type.CODE
-        return self.dg._enqueue("markdown", code_proto)
-
     @gather_metrics("caption")
     def caption(
         self,