streamlit-nightly 1.45.1.dev20250507__py3-none-any.whl → 1.45.1.dev20250509__py3-none-any.whl

streamlit/elements/lib/built_in_chart_utils.py

@@ -126,7 +126,7 @@ _NON_EXISTENT_COLUMN_NAME: Final = "DOES_NOT_EXIST" + _PROTECTION_SUFFIX
 
 def maybe_raise_stack_warning(
     stack: bool | ChartStackType | None, command: str | None, docs_link: str
-):
+) -> None:
     # Check that the stack parameter is valid, raise more informative error if not
     if stack not in (None, True, False, "normalize", "center", "layered"):
         raise StreamlitAPIException(
@@ -373,7 +373,7 @@ def _infer_vegalite_type(
     ]:
         return "quantitative"
 
-    elif typ == "categorical" and data.cat.ordered:
+    if typ == "categorical" and data.cat.ordered:
         # The original code returns a tuple here:
         # return ("ordinal", data.cat.categories.tolist())  # noqa: ERA001
         # But returning the tuple here isn't compatible with our
@@ -381,9 +381,9 @@ def _infer_vegalite_type(
         # Altair already extracts the correct sort order somewhere else.
         # More info about the issue here: https://github.com/streamlit/streamlit/issues/7776
         return "ordinal"
-    elif typ in ["string", "bytes", "categorical", "boolean", "mixed", "unicode"]:
+    if typ in ["string", "bytes", "categorical", "boolean", "mixed", "unicode"]:
         return "nominal"
-    elif typ in [
+    if typ in [
         "datetime",
         "datetime64",
         "timedelta",
@@ -393,14 +393,13 @@ def _infer_vegalite_type(
         "period",
     ]:
         return "temporal"
-    else:
-        # STREAMLIT MOD: I commented this out since Streamlit doesn't use warnings.warn.
-        # > warnings.warn(
-        # >     "I don't know how to infer vegalite type from '{}'.  "
-        # >     "Defaulting to nominal.".format(typ),
-        # >     stacklevel=1,
-        # > )
-        return "nominal"
+    # STREAMLIT MOD: I commented this out since Streamlit doesn't use warnings.warn.
+    # > warnings.warn(
+    # >     "I don't know how to infer vegalite type from '{}'.  "
+    # >     "Defaulting to nominal.".format(typ),
+    # >     stacklevel=1,
+    # > )
+    return "nominal"
 
 
 def _get_pandas_index_attr(
@@ -610,7 +609,9 @@ def _drop_unused_columns(df: pd.DataFrame, *column_names: str | None) -> pd.Data
     return df[keep]
 
 
-def _maybe_convert_color_column_in_place(df: pd.DataFrame, color_column: str | None):
+def _maybe_convert_color_column_in_place(
+    df: pd.DataFrame, color_column: str | None
+) -> None:
     """If needed, convert color column to a format Vega understands."""
     if color_column is None or len(df[color_column]) == 0:
         return
@@ -669,18 +670,17 @@ def _parse_x_column(df: pd.DataFrame, x_from_user: str | None) -> str | None:
     if x_from_user is None:
         return None
 
-    elif isinstance(x_from_user, str):
+    if isinstance(x_from_user, str):
         if x_from_user not in df.columns:
             raise StreamlitColumnNotFoundError(df, x_from_user)
 
         return x_from_user
 
-    else:
-        raise StreamlitAPIException(
-            "x parameter should be a column name (str) or None to use the "
-            f" dataframe's index. Value given: {x_from_user} "
-            f"(type {type(x_from_user)})"
-        )
+    raise StreamlitAPIException(
+        "x parameter should be a column name (str) or None to use the "
+        f" dataframe's index. Value given: {x_from_user} "
+        f"(type {type(x_from_user)})"
+    )
 
 
 def _parse_y_columns(
@@ -935,9 +935,9 @@ def _update_encoding_with_stack(
     encoding: alt.X | alt.Y,
 ) -> None:
     if stack is None:
-        return None
+        return
     # Our layered option maps to vega's stack=False option
-    elif stack == "layered":
+    if stack == "layered":
         stack = False
 
     encoding["stack"] = stack
@@ -965,7 +965,7 @@ def _get_color_encoding(
             return alt.ColorValue(to_css_color(cast("Any", color_value)))
 
         # If the color value is a list of colors of approriate length, return that.
-        elif isinstance(color_value, (list, tuple)):
+        if isinstance(color_value, (list, tuple)):
             color_values = cast("Collection[Color]", color_value)
 
             if len(color_values) != len(y_column_list):
@@ -973,18 +973,17 @@ def _get_color_encoding(
 
             if len(color_values) == 1:
                 return alt.ColorValue(to_css_color(cast("Any", color_value[0])))
-            else:
-                return alt.Color(
-                    field=color_column if color_column is not None else alt.Undefined,
-                    scale=alt.Scale(range=[to_css_color(c) for c in color_values]),
-                    legend=_COLOR_LEGEND_SETTINGS,
-                    type="nominal",
-                    title=" ",
-                )
+            return alt.Color(
+                field=color_column if color_column is not None else alt.Undefined,
+                scale=alt.Scale(range=[to_css_color(c) for c in color_values]),
+                legend=_COLOR_LEGEND_SETTINGS,
+                type="nominal",
+                title=" ",
+            )
 
         raise StreamlitInvalidColorError(df, color_from_user)
 
-    elif color_column is not None:
+    if color_column is not None:
         column_type: VegaLiteType
 
         if color_column == _MELTED_COLOR_COLUMN_NAME:
@@ -1037,16 +1036,15 @@ def _get_size_encoding(
                 legend=_SIZE_LEGEND_SETTINGS,
             )
 
-        elif isinstance(size_value, (float, int)):
+        if isinstance(size_value, (float, int)):
             return alt.SizeValue(size_value)
-        elif size_value is None:
+        if size_value is None:
             return alt.SizeValue(100)
-        else:
-            raise StreamlitAPIException(
-                f"This does not look like a valid size: {size_value!r}"
-            )
+        raise StreamlitAPIException(
+            f"This does not look like a valid size: {size_value!r}"
+        )
 
-    elif size_column is not None or size_value is not None:
+    if size_column is not None or size_value is not None:
         raise Error(
             f"Chart type {chart_type.name} does not support size argument. "
             "This should never happen!"

streamlit/elements/lib/color_util.py

@@ -83,7 +83,7 @@ def to_css_color(color: MaybeColor) -> Color:
         ctuple = _normalize_tuple(ctuple, _int_formatter, _float_formatter)
         if len(ctuple) == 3:
             return f"rgb({ctuple[0]}, {ctuple[1]}, {ctuple[2]})"
-        elif len(ctuple) == 4:
+        if len(ctuple) == 4:
             c4tuple = cast("MixedRGBAColorTuple", ctuple)
             return f"rgba({c4tuple[0]}, {c4tuple[1]}, {c4tuple[2]}, {c4tuple[3]})"
 
@@ -155,7 +155,7 @@ def _to_color_tuple(
     color: MaybeColor,
     rgb_formatter: Callable[[float, MaybeColor], float],
     alpha_formatter: Callable[[float, MaybeColor], float],
-):
+) -> ColorTuple:
     """Convert a potential color to a color tuple.
 
     The exact type of color tuple this outputs is dictated by the formatter parameters.
@@ -224,7 +224,7 @@ def _normalize_tuple(
         b = rgb_formatter(color[2], color)
         return r, g, b
 
-    elif len(color) == 4:
+    if len(color) == 4:
         color_4tuple = cast("Color4Tuple", color)
         r = rgb_formatter(color_4tuple[0], color_4tuple)
         g = rgb_formatter(color_4tuple[1], color_4tuple)

streamlit/elements/lib/column_types.py

@@ -1313,7 +1313,7 @@ def ImageColumn(
     width: ColumnWidth | None = None,
     help: str | None = None,
     pinned: bool | None = None,
-):
+) -> ColumnConfig:
     """Configure an image column in ``st.dataframe`` or ``st.data_editor``.
 
     The cell values need to be one of:
@@ -1403,7 +1403,7 @@ def ListColumn(
     width: ColumnWidth | None = None,
     help: str | None = None,
     pinned: bool | None = None,
-):
+) -> ColumnConfig:
     """Configure a list column in ``st.dataframe`` or ``st.data_editor``.
 
     This is the default column type for list-like values. List columns are not editable

streamlit/elements/lib/dialog.py

@@ -105,14 +105,14 @@ class Dialog(DeltaGenerator):
         cursor: Cursor | None,
         parent: DeltaGenerator | None,
         block_type: str | None,
-    ):
+    ) -> None:
         super().__init__(root_container, cursor, parent, block_type)
 
         # Initialized in `_create()`:
         self._current_proto: BlockProto | None = None
         self._delta_path: list[int] | None = None
 
-    def _update(self, should_open: bool):
+    def _update(self, should_open: bool) -> None:
         """Send an updated proto message to indicate the open-status for the dialog."""
 
         assert self._current_proto is not None, "Dialog not correctly initialized!"

streamlit/elements/lib/event_utils.py

@@ -26,7 +26,7 @@ class AttributeDictionary(dict[Any, Any]):
     attribute-style access.
     """
 
-    def __getattr__(self, key):
+    def __getattr__(self, key: str) -> Any:
         try:
             item = self.__getitem__(key)
             return AttributeDictionary(item) if isinstance(item, dict) else item

streamlit/elements/lib/mutable_status_container.py

@@ -88,7 +88,7 @@ class StatusContainer(DeltaGenerator):
         cursor: Cursor | None,
         parent: DeltaGenerator | None,
         block_type: str | None,
-    ):
+    ) -> None:
         super().__init__(root_container, cursor, parent, block_type)
 
         # Initialized in `_create()`:

streamlit/elements/lib/policies.py

@@ -126,7 +126,7 @@ def check_cache_replay_rules() -> None:
         exception(CachedWidgetWarning())
 
 
-def check_fragment_path_policy(dg: DeltaGenerator):
+def check_fragment_path_policy(dg: DeltaGenerator) -> None:
     """Ensures that the current widget is not written outside of the
     fragment's delta path.
 
@@ -168,7 +168,7 @@ def check_widget_policies(
     default_value: Sequence[Any] | Any | None = None,
     writes_allowed: bool = True,
     enable_check_callback_rules: bool = True,
-):
+) -> None:
     """Check all widget policies for the given DeltaGenerator."""
     check_fragment_path_policy(dg)
     check_cache_replay_rules()
@@ -179,7 +179,7 @@ def check_widget_policies(
     )
 
 
-def maybe_raise_label_warnings(label: str | None, label_visibility: str | None):
+def maybe_raise_label_warnings(label: str | None, label_visibility: str | None) -> None:
     if not label:
         _LOGGER.warning(
             "`label` got an empty value. This is discouraged for accessibility "

streamlit/elements/lib/utils.py

@@ -70,9 +70,9 @@ def get_label_visibility_proto_value(
 
     if label_visibility_string == "visible":
         return LabelVisibilityMessage.LabelVisibilityOptions.VISIBLE
-    elif label_visibility_string == "hidden":
+    if label_visibility_string == "hidden":
         return LabelVisibilityMessage.LabelVisibilityOptions.HIDDEN
-    elif label_visibility_string == "collapsed":
+    if label_visibility_string == "collapsed":
         return LabelVisibilityMessage.LabelVisibilityOptions.COLLAPSED
 
     raise ValueError(f"Unknown label visibility value: {label_visibility_string}")
@@ -85,9 +85,9 @@ def get_chat_input_accept_file_proto_value(
 
     if accept_file_value is False:
         return ChatInput.AcceptFile.NONE
-    elif accept_file_value is True:
+    if accept_file_value is True:
         return ChatInput.AcceptFile.SINGLE
-    elif accept_file_value == "multiple":
+    if accept_file_value == "multiple":
         return ChatInput.AcceptFile.MULTIPLE
 
     raise ValueError(f"Unknown accept file value: {accept_file_value}")
@@ -240,7 +240,7 @@ def compute_and_register_element_id(
     return element_id
 
 
-def save_for_app_testing(ctx: ScriptRunContext, k: str, v: Any):
+def save_for_app_testing(ctx: ScriptRunContext, k: str, v: Any) -> None:
     if config.get_option("global.appTest"):
         try:
             ctx.session_state[TESTING_KEY][k] = v

streamlit/elements/map.py

@@ -94,21 +94,26 @@ class MapMixin:
         This is a wrapper around ``st.pydeck_chart`` to quickly create
         scatterplot charts on top of a map, with auto-centering and auto-zoom.
 
-        When using this command, Mapbox provides the map tiles to render map
-        content. Note that Mapbox is a third-party product and Streamlit accepts
-        no responsibility or liability of any kind for Mapbox or for any content
-        or information made available by Mapbox.
-
-        Mapbox requires users to register and provide a token before users can
-        request map tiles. Currently, Streamlit provides this token for you, but
-        this could change at any time. We strongly recommend all users create and
-        use their own personal Mapbox token to avoid any disruptions to their
-        experience. You can do this with the ``mapbox.token`` config option. The
-        use of Mapbox is governed by Mapbox's Terms of Use.
-
-        To get a token for yourself, create an account at https://mapbox.com.
-        For more info on how to set config options, see
-        https://docs.streamlit.io/develop/api-reference/configuration/config.toml.
+        When using this command, a service called Carto_ provides the map tiles to render
+        map content. If you're using advanced PyDeck features you may need to obtain
+        an API key from Carto first. You can do that as
+        ``pydeck.Deck(api_keys={"carto": YOUR_KEY})`` or by setting the CARTO_API_KEY
+        environment variable. See `PyDeck's documentation`_ for more information.
+
+        Another common provider for map tiles is Mapbox_. If you prefer to use that,
+        you'll need to create an account at https://mapbox.com and specify your Mapbox
+        key when creating the ``pydeck.Deck`` object. You can do that as
+        ``pydeck.Deck(api_keys={"mapbox": YOUR_KEY})`` or by setting the MAPBOX_API_KEY
+        environment variable.
+
+        .. _Carto: https://carto.com
+        .. _Mapbox: https://mapbox.com
+        .. _PyDeck's documentation: https://deckgl.readthedocs.io/en/latest/deck.html
+
+        Carto and Mapbox are third-party products and Streamlit accepts no responsibility
+        or liability of any kind for Carto or Mapbox, or for any content or information
+        made available by Carto or Mapbox. The use of Carto or Mapbox is governed by
+        their respective Terms of Use.
 
         Parameters
         ----------

streamlit/elements/progress.py

@@ -61,26 +61,23 @@ def _check_float_between(value: float, low: float = 0.0, high: float = 1.0) -> b
     )
 
 
-def _get_value(value):
+def _get_value(value: FloatOrInt) -> int:
     if isinstance(value, int):
         if 0 <= value <= 100:
             return value
-        else:
-            raise StreamlitAPIException(
-                "Progress Value has invalid value [0, 100]: %d" % value
-            )
+        raise StreamlitAPIException(
+            "Progress Value has invalid value [0, 100]: %d" % value
+        )
 
-    elif isinstance(value, float):
+    if isinstance(value, float):
         if _check_float_between(value, low=0.0, high=1.0):
             return int(value * 100)
-        else:
-            raise StreamlitAPIException(
-                "Progress Value has invalid value [0.0, 1.0]: %f" % value
-            )
-    else:
         raise StreamlitAPIException(
-            "Progress Value has invalid type: %s" % type(value).__name__
+            "Progress Value has invalid value [0.0, 1.0]: %f" % value
         )
+    raise StreamlitAPIException(
+        "Progress Value has invalid type: %s" % type(value).__name__
+    )
 
 
 def _get_text(text: str | None) -> str | None:

streamlit/elements/vega_charts.py

@@ -253,7 +253,7 @@ class VegaLiteStateSerde:
 def _prepare_vega_lite_spec(
     spec: VegaLiteSpec,
     use_container_width: bool,
-    **kwargs,
+    **kwargs: Any,
 ) -> VegaLiteSpec:
     if kwargs:
         # Support passing in kwargs.
@@ -345,7 +345,7 @@ def _convert_altair_to_vega_lite_spec(
 
     datasets = {}
 
-    def id_transform(data) -> dict[str, str]:
+    def id_transform(data: Any) -> dict[str, str]:
         """Altair data transformer that serializes the data,
         creates a stable name based on the hash of the data,
         stores the bytes into the datasets mapping and

streamlit/elements/widgets/button_group.py

@@ -165,7 +165,7 @@ class ButtonGroupSerde(Generic[T]):
         options: Sequence[T],
         default_values: list[int],
         type: Literal["single", "multi"],
-    ):
+    ) -> None:
         self.options = options
         self.default_values = default_values
         self.type = type
@@ -250,7 +250,7 @@ def _build_proto(
     return proto
 
 
-def _maybe_raise_selection_mode_warning(selection_mode: SelectionMode):
+def _maybe_raise_selection_mode_warning(selection_mode: SelectionMode) -> None:
     """Check if the selection_mode value is valid or raise exception otherwise."""
     if selection_mode not in ["single", "multi"]:
         raise StreamlitAPIException(

streamlit/elements/widgets/data_editor.py

@@ -477,7 +477,7 @@ def _fix_column_headers(data_df: pd.DataFrame) -> None:
         )
 
 
-def _check_column_names(data_df: pd.DataFrame):
+def _check_column_names(data_df: pd.DataFrame) -> None:
     """Check if the column names in the provided dataframe are valid.
 
     It's not allowed to have duplicate column names or column names that are
@@ -511,7 +511,7 @@ def _check_type_compatibilities(
     data_df: pd.DataFrame,
     columns_config: ColumnConfigMapping,
     dataframe_schema: DataframeSchema,
-):
+) -> None:
     """Check column type to data type compatibility.
 
     Iterates the index and all columns of the dataframe to check if

streamlit/elements/widgets/multiselect.py

@@ -75,7 +75,7 @@ class MultiSelectSerde(Generic[T]):
         formatted_options: list[str],
         formatted_option_to_option_index: dict[str, int],
         default_options_indices: list[int] | None = None,
-    ):
+    ) -> None:
         """Initialize the MultiSelectSerde.
 
         We do not store an option_to_formatted_option mapping because the generic
@@ -140,7 +140,7 @@ def _get_default_count(default: Sequence[Any] | Any | None) -> int:
 
 def _check_max_selections(
     selections: Sequence[Any] | Any | None, max_selections: int | None
-):
+) -> None:
     if max_selections is None:
         return
 

streamlit/elements/widgets/selectbox.py

@@ -72,7 +72,7 @@ class SelectboxSerde(Generic[T]):
         formatted_options: list[str],
         formatted_option_to_option_index: dict[str, int],
         default_option_index: int | None = None,
-    ):
+    ) -> None:
         """Initialize the SelectboxSerde.
 
         We do not store an option_to_formatted_option mapping because the generic

streamlit/elements/widgets/slider.py

@@ -85,8 +85,8 @@ SliderDatelikeSpanT: TypeAlias = Union[
 StepNumericT: TypeAlias = SliderNumericT
 StepDatelikeT: TypeAlias = timedelta
 
-SliderStep = Union[int, float, timedelta]
-SliderScalar = Union[int, float, date, time, datetime]
+SliderStep: TypeAlias = Union[int, float, timedelta]
+SliderScalar: TypeAlias = Union[int, float, date, time, datetime]
 SliderValueT = TypeVar("SliderValueT", int, float, date, time, datetime)
 SliderValueGeneric: TypeAlias = Union[
     SliderValueT,
@@ -162,7 +162,7 @@ class SliderSerde:
     single_value: bool
     orig_tz: tzinfo | None
 
-    def deserialize_single_value(self, value: float):
+    def deserialize_single_value(self, value: float) -> SliderScalar:
         if self.data_type == SliderProto.INT:
             return int(value)
         if self.data_type == SliderProto.DATETIME:
@@ -177,7 +177,7 @@ class SliderSerde:
             )
         return value
 
-    def deserialize(self, ui_value: list[float] | None):
+    def deserialize(self, ui_value: list[float] | None) -> Any:
         if ui_value is not None:
             val = ui_value
         else:
@@ -185,8 +185,10 @@ class SliderSerde:
             val = self.value
 
         # The widget always returns a float array, so fix the return type if necessary
-        val = [self.deserialize_single_value(v) for v in val]
-        return val[0] if self.single_value else tuple(val)
+        deserialized_values = [self.deserialize_single_value(v) for v in val]
+        return (
+            deserialized_values[0] if self.single_value else tuple(deserialized_values)
+        )
 
     def serialize(self, v: Any) -> list[Any]:
         range_value = isinstance(v, (list, tuple))
@@ -607,10 +609,10 @@ class SliderMixin:
     def _slider(
         self,
         label: str,
-        min_value=None,
-        max_value=None,
-        value=None,
-        step=None,
+        min_value: Any = None,
+        max_value: Any = None,
+        value: Any = None,
+        step: Any = None,
         format: str | None = None,
         key: Key | None = None,
         help: str | None = None,
@@ -693,12 +695,11 @@ class SliderMixin:
         def value_to_generic_type(v):
             if isinstance(v, Integral):
                 return SUPPORTED_TYPES[Integral]
-            elif isinstance(v, Real):
+            if isinstance(v, Real):
                 return SUPPORTED_TYPES[Real]
-            else:
-                return SUPPORTED_TYPES[type(v)]
+            return SUPPORTED_TYPES[type(v)]
 
-        def all_same_type(items):
+        def all_same_type(items: Any) -> bool:
             return len(set(map(value_to_generic_type, items))) < 2
 
         if not all_same_type(value):
@@ -930,6 +931,7 @@ class SliderMixin:
             for value in serialized_values:
                 # Use the deserialized values for more readable error messages for dates/times
                 deserialized_value = serde.deserialize_single_value(value)
+
                 if value < slider_proto.min:
                     raise StreamlitValueBelowMinError(
                         value=deserialized_value,

streamlit/elements/write.py

@@ -245,7 +245,7 @@ class WriteMixin:
         if not written_content:
             # If nothing was streamed, return an empty string.
             return ""
-        elif len(written_content) == 1 and isinstance(written_content[0], str):
+        if len(written_content) == 1 and isinstance(written_content[0], str):
             # If the output only contains a single string, return it as a string
             return written_content[0]
 
@@ -253,7 +253,7 @@ class WriteMixin:
         return written_content
 
     @gather_metrics("write")
-    def write(self, *args: Any, unsafe_allow_html: bool = False, **kwargs) -> None:
+    def write(self, *args: Any, unsafe_allow_html: bool = False, **kwargs: Any) -> None:
         """Displays arguments in the app.
 
         This is the Swiss Army knife of Streamlit commands: it does different
@@ -528,10 +528,7 @@ class WriteMixin:
             ):
                 flush_buffer()
                 self.write_stream(arg)
-            elif isinstance(arg, HELP_TYPES):
-                flush_buffer()
-                self.dg.help(arg)
-            elif dataclasses.is_dataclass(arg):
+            elif isinstance(arg, HELP_TYPES) or dataclasses.is_dataclass(arg):
                 flush_buffer()
                 self.dg.help(arg)
             elif inspect.isclass(arg):