streamlit-nightly 1.21.1.dev20230423__tar.gz → 1.21.1.dev20230425__tar.gz

{streamlit-nightly-1.21.1.dev20230423 → streamlit-nightly-1.21.1.dev20230425}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: streamlit-nightly
-Version: 1.21.1.dev20230423
+Version: 1.21.1.dev20230425
 Summary: A faster way to build and share data apps
 Home-page: https://streamlit.io
 Author: Snowflake Inc

{streamlit-nightly-1.21.1.dev20230423 → streamlit-nightly-1.21.1.dev20230425}/setup.py

@@ -21,7 +21,7 @@ from setuptools.command.install import install
 
 THIS_DIRECTORY = Path(__file__).parent
 
-VERSION = "1.21.1.dev20230423"  # PEP-440
+VERSION = "1.21.1.dev20230425"  # PEP-440
 
 NAME = "streamlit-nightly"
 

{streamlit-nightly-1.21.1.dev20230423 → streamlit-nightly-1.21.1.dev20230425}/streamlit/__init__.py

@@ -71,7 +71,6 @@ from streamlit.commands.query_params import (
     get_query_params as _get_query_params,
     set_query_params as _set_query_params,
 )
-from streamlit.elements.show import show as _show
 
 # Modules that the user should have access to. These are imported with "as"
 # syntax pass mypy checking with implicit_reexport disabled.
@@ -201,18 +200,12 @@ session_state = _SessionStateProxy()
 cache_data = _cache_data
 cache_resource = _cache_resource
 
-# Beta APIs
-beta_container = _gather_metrics("beta_container", _main.beta_container)
-beta_expander = _gather_metrics("beta_expander", _main.beta_expander)
-beta_columns = _gather_metrics("beta_columns", _main.beta_columns)
-
 # Experimental APIs
 experimental_user = _UserInfoProxy()
 experimental_singleton = _experimental_singleton
 experimental_memo = _experimental_memo
 experimental_get_query_params = _get_query_params
 experimental_set_query_params = _set_query_params
-experimental_show = _show
 experimental_rerun = _rerun
 experimental_data_editor = _main.experimental_data_editor
 experimental_connection = _connection_factory

streamlit-nightly-1.21.1.dev20230425/streamlit/elements/arrow.py

@@ -0,0 +1,191 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022)
+#
+# 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 collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
+
+import pyarrow as pa
+from numpy import ndarray
+from pandas import DataFrame
+
+from streamlit import type_util
+from streamlit.elements.lib.pandas_styler_utils import marshall_styler
+from streamlit.proto.Arrow_pb2 import Arrow as ArrowProto
+from streamlit.runtime.metrics_util import gather_metrics
+
+if TYPE_CHECKING:
+    from pandas.io.formats.style import Styler
+
+    from streamlit.delta_generator import DeltaGenerator
+
+Data = Union[
+    DataFrame, "Styler", pa.Table, ndarray, Iterable, Dict[str, List[Any]], None
+]
+
+
+class ArrowMixin:
+    @gather_metrics("_arrow_dataframe")
+    def _arrow_dataframe(
+        self,
+        data: Data = None,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        *,
+        use_container_width: bool = False,
+    ) -> "DeltaGenerator":
+        """Display a dataframe as an interactive table.
+
+        Parameters
+        ----------
+        data : pandas.DataFrame, pandas.Styler, pyarrow.Table, numpy.ndarray, pyspark.sql.DataFrame, snowflake.snowpark.DataFrame, Iterable, dict, or None
+            The data to display.
+
+            If 'data' is a pandas.Styler, it will be used to style its
+            underlying DataFrame.
+
+        width : int or None
+            Desired width of the dataframe element expressed in pixels. If None, the
+            width will be automatically determined.
+
+        height : int or None
+            Desired height of the dataframe element expressed in pixels. If None, the
+            height will be automatically determined.
+
+        use_container_width : bool
+            If True, set the dataframe width to the width of the parent container.
+            This takes precedence over the width argument.
+            This argument can only be supplied by keyword.
+
+        Examples
+        --------
+        >>> import streamlit as st
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>>
+        >>> df = pd.DataFrame(
+        ...    np.random.randn(50, 20),
+        ...    columns=('col %d' % i for i in range(20)))
+        ...
+        >>> st._arrow_dataframe(df)
+
+        >>> st._arrow_dataframe(df, 200, 100)
+
+        You can also pass a Pandas Styler object to change the style of
+        the rendered DataFrame:
+
+        >>> df = pd.DataFrame(
+        ...    np.random.randn(10, 20),
+        ...    columns=('col %d' % i for i in range(20)))
+        ...
+        >>> st._arrow_dataframe(df.style.highlight_max(axis=0))
+
+        """
+
+        # If pandas.Styler uuid is not provided, a hash of the position
+        # of the element will be used. This will cause a rerender of the table
+        # when the position of the element is changed.
+        delta_path = self.dg._get_delta_path_str()
+        default_uuid = str(hash(delta_path))
+
+        proto = ArrowProto()
+        proto.use_container_width = use_container_width
+        if width:
+            proto.width = width
+        if height:
+            proto.height = height
+        proto.editing_mode = ArrowProto.EditingMode.READ_ONLY
+
+        marshall(proto, data, default_uuid)
+
+        return self.dg._enqueue("arrow_data_frame", proto)
+
+    @gather_metrics("_arrow_table")
+    def _arrow_table(self, data: Data = None) -> "DeltaGenerator":
+        """Display a static table.
+
+        This differs from `st._arrow_dataframe` in that the table in this case is
+        static: its entire contents are laid out directly on the page.
+
+        Parameters
+        ----------
+        data : pandas.DataFrame, pandas.Styler, pyarrow.Table, numpy.ndarray, pyspark.sql.DataFrame, snowflake.snowpark.DataFrame, Iterable, dict, or None
+            The table data.
+
+        Example
+        -------
+        >>> import streamlit as st
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>>
+        >>> df = pd.DataFrame(
+        ...    np.random.randn(10, 5),
+        ...    columns=("col %d" % i for i in range(5)))
+        ...
+        >>> st._arrow_table(df)
+
+        """
+
+        # Check if data is uncollected, and collect it but with 100 rows max, instead of 10k rows, which is done in all other cases.
+        # Avoid this and use 100 rows in st.table, because large tables render slowly, take too much screen space, and can crush the app.
+        if type_util.is_snowpark_data_object(data) or type_util.is_type(
+            data, type_util._PYSPARK_DF_TYPE_STR
+        ):
+            data = type_util.convert_anything_to_df(data, max_unevaluated_rows=100)
+
+        # If pandas.Styler uuid is not provided, a hash of the position
+        # of the element will be used. This will cause a rerender of the table
+        # when the position of the element is changed.
+        delta_path = self.dg._get_delta_path_str()
+        default_uuid = str(hash(delta_path))
+
+        proto = ArrowProto()
+        marshall(proto, data, default_uuid)
+        return self.dg._enqueue("arrow_table", proto)
+
+    @property
+    def dg(self) -> "DeltaGenerator":
+        """Get our DeltaGenerator."""
+        return cast("DeltaGenerator", self)
+
+
+def marshall(proto: ArrowProto, data: Data, default_uuid: Optional[str] = None) -> None:
+    """Marshall pandas.DataFrame into an Arrow proto.
+
+    Parameters
+    ----------
+    proto : proto.Arrow
+        Output. The protobuf for Streamlit Arrow proto.
+
+    data : pandas.DataFrame, pandas.Styler, pyarrow.Table, numpy.ndarray, pyspark.sql.DataFrame, snowflake.snowpark.DataFrame, Iterable, dict, or None
+        Something that is or can be converted to a dataframe.
+
+    default_uuid : Optional[str]
+        If pandas.Styler UUID is not provided, this value will be used.
+        This attribute is optional and only used for pandas.Styler, other elements
+        (e.g. charts) can ignore it.
+
+    """
+    if type_util.is_pandas_styler(data):
+        # default_uuid is a string only if the data is a `Styler`,
+        # and `None` otherwise.
+        assert isinstance(
+            default_uuid, str
+        ), "Default UUID must be a string for Styler data."
+        marshall_styler(proto, data, default_uuid)
+
+    if isinstance(data, pa.Table):
+        proto.data = type_util.pyarrow_table_to_bytes(data)
+    else:
+        df = type_util.convert_anything_to_df(data)
+        proto.data = type_util.data_frame_to_bytes(df)

{streamlit-nightly-1.21.1.dev20230423 → streamlit-nightly-1.21.1.dev20230425}/streamlit/elements/data_editor.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import contextlib
 import json
 from dataclasses import dataclass
 from typing import (
@@ -34,13 +33,20 @@ from typing import (
 
 import pandas as pd
 import pyarrow as pa
-from pandas.api.types import is_datetime64_any_dtype, is_float_dtype, is_integer_dtype
-from pandas.io.formats.style import Styler
-from typing_extensions import Final, Literal, TypeAlias, TypedDict
+from typing_extensions import Literal, TypeAlias, TypedDict
 
+from streamlit import logger as _logger
 from streamlit import type_util
-from streamlit.elements.arrow import marshall_styler
 from streamlit.elements.form import current_form_id
+from streamlit.elements.lib.column_config_utils import (
+    INDEX_IDENTIFIER,
+    ColumnConfigMapping,
+    ColumnDataKind,
+    DataframeSchema,
+    determine_dataframe_schema,
+    marshall_column_config,
+)
+from streamlit.elements.lib.pandas_styler_utils import marshall_styler
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Arrow_pb2 import Arrow as ArrowProto
 from streamlit.runtime.metrics_util import gather_metrics
@@ -55,10 +61,11 @@ from streamlit.type_util import DataFormat, DataFrameGenericAlias, Key, is_type,
 
 if TYPE_CHECKING:
     import numpy as np
+    from pandas.io.formats.style import Styler
 
     from streamlit.delta_generator import DeltaGenerator
 
-_INDEX_IDENTIFIER: Final = "index"
+_LOGGER = _logger.get_logger("root")
 
 # All formats that support direct editing, meaning that these
 # formats will be returned with the same type when used with data_editor.
@@ -81,7 +88,7 @@ EditableData = TypeVar(
 DataTypes: TypeAlias = Union[
     pd.DataFrame,
     pd.Index,
-    Styler,
+    "Styler",
     pa.Table,
     "np.ndarray[Any, np.dtype[np.float64]]",
     Tuple[Any],
@@ -91,25 +98,6 @@ DataTypes: TypeAlias = Union[
 ]
 
 
-class ColumnConfig(TypedDict, total=False):
-    width: Optional[int]
-    title: Optional[str]
-    type: Optional[
-        Literal[
-            "text",
-            "number",
-            "boolean",
-            "list",
-            "categorical",
-        ]
-    ]
-    hidden: Optional[bool]
-    editable: Optional[bool]
-    alignment: Optional[Literal["left", "center", "right"]]
-    metadata: Optional[Dict[str, Any]]
-    column: Optional[Union[str, int]]
-
-
 class EditingState(TypedDict, total=False):
     """
     A dictionary representing the current state of the data editor.
@@ -133,44 +121,6 @@ class EditingState(TypedDict, total=False):
     deleted_rows: List[int]
 
 
-# A mapping of column names/IDs to column configs.
-ColumnConfigMapping: TypeAlias = Dict[Union[int, str], ColumnConfig]
-
-
-def _marshall_column_config(
-    proto: ArrowProto, columns: Optional[Dict[Union[int, str], ColumnConfig]] = None
-) -> None:
-    """Marshall the column config into the proto.
-
-    Parameters
-    ----------
-    proto : ArrowProto
-        The proto to marshall into.
-
-    columns : Optional[ColumnConfigMapping]
-        The column config to marshall.
-    """
-    if columns is None:
-        columns = {}
-
-    # Ignore all None values and prefix columns specified by index
-    def remove_none_values(input_dict: Dict[Any, Any]) -> Dict[Any, Any]:
-        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
-
-    proto.columns = json.dumps(
-        {
-            (f"col:{str(k)}" if isinstance(k, int) else k): v
-            for (k, v) in remove_none_values(columns).items()
-        }
-    )
-
-
 @dataclass
 class DataEditorSerde:
     """DataEditorSerde is used to serialize and deserialize the data editor state."""
@@ -190,7 +140,10 @@ class DataEditorSerde:
         return json.dumps(editing_state, default=str)
 
 
-def _parse_value(value: Union[str, int, float, bool, None], dtype) -> Any:
+def _parse_value(
+    value: str | int | float | bool | None,
+    column_data_kind: ColumnDataKind,
+) -> Any:
     """Convert a value to the correct type.
 
     Parameters
@@ -198,8 +151,9 @@ def _parse_value(value: Union[str, int, float, bool, None], dtype) -> Any:
     value : str | int | float | bool | None
         The value to convert.
 
-    dtype
-        The type of the value.
+    column_data_kind : ColumnDataKind
+        The determined data kind of the column. The column data kind refers to the
+        shared data type of the values in the column (e.g. integer, float, string).
 
     Returns
     -------
@@ -208,23 +162,53 @@ def _parse_value(value: Union[str, int, float, bool, None], dtype) -> Any:
     if value is None:
         return None
 
-    # TODO(lukasmasuch): how to deal with date & time columns?
+    try:
+        if column_data_kind == ColumnDataKind.STRING:
+            return str(value)
 
-    # Datetime values try to parse the value to datetime:
-    # The value is expected to be a ISO 8601 string
-    if is_datetime64_any_dtype(dtype):
-        return pd.to_datetime(value, errors="ignore")
-    elif is_integer_dtype(dtype):
-        with contextlib.suppress(ValueError):
+        if column_data_kind == ColumnDataKind.INTEGER:
             return int(value)
-    elif is_float_dtype(dtype):
-        with contextlib.suppress(ValueError):
+
+        if column_data_kind == ColumnDataKind.FLOAT:
             return float(value)
+
+        if column_data_kind == ColumnDataKind.BOOLEAN:
+            return bool(value)
+
+        if column_data_kind in [
+            ColumnDataKind.DATETIME,
+            ColumnDataKind.DATE,
+            ColumnDataKind.TIME,
+        ]:
+            datetime_value = pd.to_datetime(value, utc=False)
+
+            if datetime_value is pd.NaT:
+                return None
+
+            if isinstance(datetime_value, pd.Timestamp):
+                datetime_value = datetime_value.to_pydatetime()
+
+            if column_data_kind == ColumnDataKind.DATETIME:
+                return datetime_value
+
+            if column_data_kind == ColumnDataKind.DATE:
+                return datetime_value.date()
+
+            if column_data_kind == ColumnDataKind.TIME:
+                return datetime_value.time()
+
+    except (ValueError, pd.errors.ParserError) as ex:
+        _LOGGER.warning(
+            "Failed to parse value %s as %s. Exception: %s", value, column_data_kind, ex
+        )
+        return None
     return value
 
 
 def _apply_cell_edits(
-    df: pd.DataFrame, edited_cells: Mapping[str, str | int | float | bool | None]
+    df: pd.DataFrame,
+    edited_cells: Mapping[str, str | int | float | bool | None],
+    dataframe_schema: DataframeSchema,
 ) -> None:
     """Apply cell edits to the provided dataframe (inplace).
 
@@ -237,6 +221,8 @@ def _apply_cell_edits(
         A dictionary of cell edits. The keys are the cell ids in the format
         "row:column" and the values are the new cell values.
 
+    dataframe_schema: DataframeSchema
+        The schema of the dataframe.
     """
     index_count = df.index.nlevels or 0
 
@@ -247,17 +233,21 @@ def _apply_cell_edits(
             # The edited cell is part of the index
             # To support multi-index in the future: use a tuple of values here
             # instead of a single value
-            df.index.values[row_pos] = _parse_value(value, df.index.dtype)
+            df.index.values[row_pos] = _parse_value(value, dataframe_schema[col_pos])
         else:
             # We need to subtract the number of index levels from col_pos
             # to get the correct column position for Pandas DataFrames
             mapped_column = col_pos - index_count
             df.iat[row_pos, mapped_column] = _parse_value(
-                value, df.iloc[:, mapped_column].dtype
+                value, dataframe_schema[col_pos]
             )
 
 
-def _apply_row_additions(df: pd.DataFrame, added_rows: List[Dict[str, Any]]) -> None:
+def _apply_row_additions(
+    df: pd.DataFrame,
+    added_rows: List[Dict[str, Any]],
+    dataframe_schema: DataframeSchema,
+) -> None:
     """Apply row additions to the provided dataframe (inplace).
 
     Parameters
@@ -268,6 +258,9 @@ def _apply_row_additions(df: pd.DataFrame, added_rows: List[Dict[str, Any]]) ->
     added_rows : List[Dict[str, Any]]
         A list of row additions. Each row addition is a dictionary with the
         column position as key and the new cell value as value.
+
+    dataframe_schema: DataframeSchema
+        The schema of the dataframe.
     """
     if not added_rows:
         return
@@ -279,7 +272,7 @@ def _apply_row_additions(df: pd.DataFrame, added_rows: List[Dict[str, Any]]) ->
     # combination with loc. As a workaround, we manually track the values here:
     range_index_stop = None
     range_index_step = None
-    if type(df.index) == pd.RangeIndex:
+    if isinstance(df.index, pd.RangeIndex):
         range_index_stop = df.index.stop
         range_index_step = df.index.step
 
@@ -292,14 +285,12 @@ def _apply_row_additions(df: pd.DataFrame, added_rows: List[Dict[str, Any]]) ->
             if col_pos < index_count:
                 # To support multi-index in the future: use a tuple of values here
                 # instead of a single value
-                index_value = _parse_value(value, df.index.dtype)
+                index_value = _parse_value(value, dataframe_schema[col_pos])
             else:
                 # We need to subtract the number of index levels from the col_pos
                 # to get the correct column position for Pandas DataFrames
                 mapped_column = col_pos - index_count
-                new_row[mapped_column] = _parse_value(
-                    value, df.iloc[:, mapped_column].dtype
-                )
+                new_row[mapped_column] = _parse_value(value, dataframe_schema[col_pos])
         # Append the new row to the dataframe
         if range_index_stop is not None:
             df.loc[range_index_stop, :] = new_row
@@ -329,7 +320,11 @@ def _apply_row_deletions(df: pd.DataFrame, deleted_rows: List[int]) -> None:
     df.drop(df.index[deleted_rows], inplace=True)
 
 
-def _apply_dataframe_edits(df: pd.DataFrame, data_editor_state: EditingState) -> None:
+def _apply_dataframe_edits(
+    df: pd.DataFrame,
+    data_editor_state: EditingState,
+    dataframe_schema: DataframeSchema,
+) -> None:
     """Apply edits to the provided dataframe (inplace).
 
     This includes cell edits, row additions and row deletions.
@@ -341,12 +336,15 @@ def _apply_dataframe_edits(df: pd.DataFrame, data_editor_state: EditingState) ->
 
     data_editor_state : EditingState
         The editing state of the data editor component.
+
+    dataframe_schema: DataframeSchema
+        The schema of the dataframe.
     """
     if data_editor_state.get("edited_cells"):
-        _apply_cell_edits(df, data_editor_state["edited_cells"])
+        _apply_cell_edits(df, data_editor_state["edited_cells"], dataframe_schema)
 
     if data_editor_state.get("added_rows"):
-        _apply_row_additions(df, data_editor_state["added_rows"])
+        _apply_row_additions(df, data_editor_state["added_rows"], dataframe_schema)
 
     if data_editor_state.get("deleted_rows"):
         _apply_row_deletions(df, data_editor_state["deleted_rows"])
@@ -376,7 +374,7 @@ def _apply_data_specific_configs(
         if type_util.is_colum_type_arrow_incompatible(column_data):
             if column_name not in columns_config:
                 columns_config[column_name] = {}
-            columns_config[column_name]["editable"] = False
+            columns_config[column_name]["disabled"] = True
             # Convert incompatible type to string
             data_df[column_name] = column_data.astype(str)
 
@@ -393,9 +391,9 @@ def _apply_data_specific_configs(
         DataFormat.LIST_OF_ROWS,
         DataFormat.COLUMN_VALUE_MAPPING,
     ]:
-        if _INDEX_IDENTIFIER not in columns_config:
-            columns_config[_INDEX_IDENTIFIER] = {}
-        columns_config[_INDEX_IDENTIFIER]["hidden"] = True
+        if INDEX_IDENTIFIER not in columns_config:
+            columns_config[INDEX_IDENTIFIER] = {}
+        columns_config[INDEX_IDENTIFIER]["hidden"] = True
 
     # Rename the first column to "value" for some of the data formats
     if data_format in [
@@ -593,13 +591,24 @@ class DataEditorMixin:
 
         # Temporary workaround: We hide range indices if num_rows is dynamic.
         # since the current way of handling this index during editing is a bit confusing.
-        if type(data_df.index) is pd.RangeIndex and num_rows == "dynamic":
-            if _INDEX_IDENTIFIER not in columns_config:
-                columns_config[_INDEX_IDENTIFIER] = {}
-            columns_config[_INDEX_IDENTIFIER]["hidden"] = True
+        if isinstance(data_df.index, pd.RangeIndex) and num_rows == "dynamic":
+            if INDEX_IDENTIFIER not in columns_config:
+                columns_config[INDEX_IDENTIFIER] = {}
+            columns_config[INDEX_IDENTIFIER]["hidden"] = True
+
+        # Convert the dataframe to an arrow table which is used as the main
+        # serialization format for sending the data to the frontend.
+        # We also utilize the arrow schema to determine the data kinds of every column.
+        arrow_table = pa.Table.from_pandas(data_df)
+
+        # Determine the dataframe schema which is required for parsing edited values
+        # and for checking type compatibilities.
+        dataframe_schema = determine_dataframe_schema(data_df, arrow_table.schema)
 
         proto = ArrowProto()
+
         proto.use_container_width = use_container_width
+
         if width:
             proto.width = width
         if height:
@@ -614,14 +623,14 @@ class DataEditorMixin:
         proto.form_id = current_form_id(self.dg)
 
         if type_util.is_pandas_styler(data):
+            # Pandas styler will only work for non-editable/disabled columns.
             delta_path = self.dg._get_delta_path_str()
             default_uuid = str(hash(delta_path))
             marshall_styler(proto, data, default_uuid)
 
-        table = pa.Table.from_pandas(data_df)
-        proto.data = type_util.pyarrow_table_to_bytes(table)
+        proto.data = type_util.pyarrow_table_to_bytes(arrow_table)
 
-        _marshall_column_config(proto, columns_config)
+        marshall_column_config(proto, columns_config)
 
         serde = DataEditorSerde()
 
@@ -637,7 +646,7 @@ class DataEditorMixin:
             ctx=get_script_run_ctx(),
         )
 
-        _apply_dataframe_edits(data_df, widget_state.value)
+        _apply_dataframe_edits(data_df, widget_state.value, dataframe_schema)
         self.dg._enqueue("arrow_data_frame", proto)
         return type_util.convert_df_to_data_format(data_df, data_format)
 

{streamlit-nightly-1.21.1.dev20230423 → streamlit-nightly-1.21.1.dev20230425}/streamlit/elements/file_uploader.py

@@ -43,6 +43,15 @@ from streamlit.type_util import Key, LabelVisibility, maybe_raise_label_warnings
 SomeUploadedFiles = Optional[Union[UploadedFile, List[UploadedFile]]]
 
 
+TYPE_PAIRS = [
+    (".jpg", ".jpeg"),
+    (".mpg", ".mpeg"),
+    (".mp4", ".mpeg4"),
+    (".tif", ".tiff"),
+    (".htm", ".html"),
+]
+
+
 def _get_file_recs(
     widget_id: str, widget_value: Optional[FileUploaderStateProto]
 ) -> List[UploadedFileRec]:
@@ -390,6 +399,14 @@ class FileUploaderMixin:
                 for file_type in type
             ]
 
+            type = [t.lower() for t in type]
+
+            for x, y in TYPE_PAIRS:
+                if x in type and y not in type:
+                    type.append(y)
+                if y in type and x not in type:
+                    type.append(x)
+
         file_uploader_proto = FileUploaderProto()
         file_uploader_proto.label = label
         file_uploader_proto.type[:] = type if type is not None else []

{streamlit-nightly-1.21.1.dev20230423 → streamlit-nightly-1.21.1.dev20230425}/streamlit/elements/layouts.py

@@ -416,8 +416,3 @@ class LayoutsMixin:
     def dg(self) -> "DeltaGenerator":
         """Get our DeltaGenerator."""
         return cast("DeltaGenerator", self)
-
-    # Deprecated beta_ functions
-    beta_container = deprecate_func_name(container, "beta_container", "2021-11-02")
-    beta_expander = deprecate_func_name(expander, "beta_expander", "2021-11-02")
-    beta_columns = deprecate_func_name(columns, "beta_columns", "2021-11-02")