streamlit-nightly 1.37.2.dev20240810__py2.py3-none-any.whl → 1.37.2.dev20240813__py2.py3-none-any.whl

streamlit/elements/lib/built_in_chart_utils.py

@@ -667,10 +667,15 @@ def _get_offset_encoding(
     x_offset = alt.XOffset()
     y_offset = alt.YOffset()
 
+    # our merge gate does not find the alt.UndefinedType type for some reason
+    _color_column: str | alt.UndefinedType = (  # type: ignore[name-defined]
+        color_column if color_column is not None else alt.utils.Undefined
+    )
+
     if chart_type is ChartType.VERTICAL_BAR:
-        x_offset = alt.XOffset(field=color_column)
+        x_offset = alt.XOffset(field=_color_column)
     elif chart_type is ChartType.HORIZONTAL_BAR:
-        y_offset = alt.YOffset(field=color_column)
+        y_offset = alt.YOffset(field=_color_column)
 
     return x_offset, y_offset
 
@@ -912,11 +917,13 @@ def _get_color_encoding(
             if len(color_values) != len(y_column_list):
                 raise StreamlitColorLengthError(color_values, y_column_list)
 
-            if len(color_value) == 1:
+            if len(color_values) == 1:
                 return alt.ColorValue(to_css_color(cast(Any, color_value[0])))
             else:
                 return alt.Color(
-                    field=color_column,
+                    field=color_column
+                    if color_column is not None
+                    else alt.utils.Undefined,
                     scale=alt.Scale(range=[to_css_color(c) for c in color_values]),
                     legend=_COLOR_LEGEND_SETTINGS,
                     type="nominal",
@@ -926,7 +933,7 @@ def _get_color_encoding(
         raise StreamlitInvalidColorError(df, color_from_user)
 
     elif color_column is not None:
-        column_type: str | tuple[str, list[Any]]
+        column_type: VegaLiteType
 
         if color_column == _MELTED_COLOR_COLUMN_NAME:
             column_type = "nominal"

streamlit/elements/lib/column_config_utils.py

@@ -494,6 +494,14 @@ def apply_data_specific_configs(
         DataFormat.LIST_OF_RECORDS,
         DataFormat.LIST_OF_ROWS,
         DataFormat.COLUMN_VALUE_MAPPING,
+        # Dataframe-like objects that don't have an index:
+        DataFormat.PANDAS_ARRAY,
+        DataFormat.PANDAS_INDEX,
+        DataFormat.POLARS_DATAFRAME,
+        DataFormat.POLARS_SERIES,
+        DataFormat.POLARS_LAZYFRAME,
+        DataFormat.PYARROW_ARRAY,
+        DataFormat.RAY_DATASET,
     ]:
         update_column_config(columns_config, INDEX_IDENTIFIER, {"hidden": True})
 

streamlit/elements/lib/dialog.py

@@ -19,11 +19,14 @@ from typing import TYPE_CHECKING, Literal, cast
 
 from typing_extensions import Self, TypeAlias
 
-from streamlit.delta_generator import DeltaGenerator, _enqueue_message
+from streamlit.delta_generator import DeltaGenerator
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Block_pb2 import Block as BlockProto
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
-from streamlit.runtime.scriptrunner import get_script_run_ctx
+from streamlit.runtime.scriptrunner.script_run_context import (
+    enqueue_message,
+    get_script_run_ctx,
+)
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -127,7 +130,7 @@ class Dialog(DeltaGenerator):
         # We add a sleep here to give the web app time to react to the update. Otherwise,
         #  we might run into issues where the dialog cannot be opened again after closing
         time.sleep(0.05)
-        _enqueue_message(msg)
+        enqueue_message(msg)
 
     def open(self) -> None:
         self._update(True)

streamlit/elements/lib/mutable_status_container.py

@@ -19,10 +19,11 @@ from typing import TYPE_CHECKING, Literal, cast
 
 from typing_extensions import Self, TypeAlias
 
-from streamlit.delta_generator import DeltaGenerator, _enqueue_message
+from streamlit.delta_generator import DeltaGenerator
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.Block_pb2 import Block as BlockProto
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
+from streamlit.runtime.scriptrunner.script_run_context import enqueue_message
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -150,7 +151,7 @@ class StatusContainer(DeltaGenerator):
             self._current_state = state
 
         self._current_proto = msg.delta.add_block
-        _enqueue_message(msg)
+        enqueue_message(msg)
 
     def __enter__(self) -> Self:  # type: ignore[override]
         # This is a little dubious: we're returning a different type than

streamlit/elements/media.py

@@ -33,6 +33,7 @@ from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner import get_script_run_ctx
 from streamlit.runtime.state.common import compute_widget_id
 from streamlit.time_util import time_to_seconds
+from streamlit.type_util import NumpyShape
 
 if TYPE_CHECKING:
     from typing import Any
@@ -41,6 +42,7 @@ if TYPE_CHECKING:
 
     from streamlit.delta_generator import DeltaGenerator
 
+
 MediaData: TypeAlias = Union[
     str, bytes, io.BytesIO, io.RawIOBase, io.BufferedReader, "npt.NDArray[Any]", None
 ]
@@ -633,29 +635,29 @@ def _validate_and_normalize(data: npt.NDArray[Any]) -> tuple[bytes, int]:
     # to st.audio data)
     import numpy as np
 
-    data: npt.NDArray[Any] = np.array(data, dtype=float)
+    transformed_data: npt.NDArray[Any] = np.array(data, dtype=float)
 
-    if len(data.shape) == 1:
+    if len(cast(NumpyShape, transformed_data.shape)) == 1:
         nchan = 1
-    elif len(data.shape) == 2:
+    elif len(transformed_data.shape) == 2:
         # In wave files,channels are interleaved. E.g.,
         # "L1R1L2R2..." for stereo. See
         # http://msdn.microsoft.com/en-us/library/windows/hardware/dn653308(v=vs.85).aspx
         # for channel ordering
-        nchan = data.shape[0]
-        data = data.T.ravel()
+        nchan = transformed_data.shape[0]
+        transformed_data = transformed_data.T.ravel()
     else:
         raise StreamlitAPIException("Numpy array audio input must be a 1D or 2D array.")
 
-    if data.size == 0:
-        return data.astype(np.int16).tobytes(), nchan
+    if transformed_data.size == 0:
+        return transformed_data.astype(np.int16).tobytes(), nchan
 
-    max_abs_value = np.max(np.abs(data))
+    max_abs_value = np.max(np.abs(transformed_data))
     # 16-bit samples are stored as 2's-complement signed integers,
     # ranging from -32768 to 32767.
     # scaled_data is PCM 16 bit numpy array, that's why we multiply [-1, 1] float
     # values to 32_767 == 2 ** 15 - 1.
-    np_array = (data / max_abs_value) * 32767
+    np_array = (transformed_data / max_abs_value) * 32767
     scaled_data = np_array.astype(np.int16)
     return scaled_data.tobytes(), nchan
 

streamlit/elements/metric.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import TYPE_CHECKING, Literal, Union, cast
+from typing import TYPE_CHECKING, Any, Literal, Union, cast
 
 from typing_extensions import TypeAlias
 
@@ -36,7 +36,7 @@ if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
 
 
-Value: TypeAlias = Union["np.integer", "np.floating", float, int, str, None]
+Value: TypeAlias = Union["np.integer[Any]", "np.floating[Any]", float, int, str, None]
 Delta: TypeAlias = Union[float, int, str, None]
 DeltaColor: TypeAlias = Literal["normal", "inverse", "off"]
 

streamlit/elements/widgets/number_input.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 import numbers
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import TYPE_CHECKING, Literal, Union, cast, overload
+from typing import TYPE_CHECKING, Literal, TypeVar, Union, cast, overload
 
 from typing_extensions import TypeAlias
 
@@ -51,6 +51,8 @@ if TYPE_CHECKING:
 
 
 Number: TypeAlias = Union[int, float]
+IntOrNone = TypeVar("IntOrNone", int, None)
+FloatOrNone = TypeVar("FloatOrNone", float, None)
 
 
 @dataclass
@@ -73,47 +75,91 @@ class NumberInputSerde:
 
 
 class NumberInputMixin:
+    # For easier readability, all the arguments with un-changing types across these overload signatures have been
+    # collapsed onto a single line.
+
+    # fmt: off
+    # If "min_value: int" is given and all other numerical inputs are
+    #   "int"s or not provided (value optionally being "min"), return "int"
+    # If "min_value: int, value: None" is given and all other numerical inputs
+    #   are "int"s or not provided, return "int | None"
     @overload
     def number_input(
         self,
         label: str,
-        min_value: Number | None = None,
-        max_value: Number | None = None,
-        value: Number | Literal["min"] = "min",
-        step: Number | None = None,
-        format: str | None = None,
-        key: Key | None = None,
-        help: str | None = None,
-        on_change: WidgetCallback | None = None,
-        args: WidgetArgs | None = None,
-        kwargs: WidgetKwargs | None = None,
-        *,  # keyword-only arguments:
-        placeholder: str | None = None,
-        disabled: bool = False,
-        label_visibility: LabelVisibility = "visible",
-    ) -> Number:
-        pass
-
+        min_value: int,
+        max_value: int | None = None,
+        value: IntOrNone | Literal["min"] = "min",
+        step: int | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, placeholder: str | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> int | IntOrNone:
+        ...
+
+    # If "max_value: int" is given and all other numerical inputs are
+    #   "int"s or not provided (value optionally being "min"), return "int"
+    # If "max_value: int, value=None" is given and all other numerical inputs
+    #   are "int"s or not provided, return "int | None"
     @overload
     def number_input(
         self,
         label: str,
-        min_value: Number | None = None,
-        max_value: Number | None = None,
-        value: None = None,
-        step: Number | None = None,
-        format: str | None = None,
-        key: Key | None = None,
-        help: str | None = None,
-        on_change: WidgetCallback | None = None,
-        args: WidgetArgs | None = None,
-        kwargs: WidgetKwargs | None = None,
-        *,  # keyword-only arguments:
-        placeholder: str | None = None,
-        disabled: bool = False,
-        label_visibility: LabelVisibility = "visible",
-    ) -> Number | None:
-        pass
+        min_value: int | None = None,
+        *,
+        max_value: int,
+        value: IntOrNone | Literal["min"] = "min",
+        step: int | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, placeholder: str | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> int | IntOrNone:
+        ...
+
+    # If "value=int" is given and all other numerical inputs are "int"s
+    #   or not provided, return "int"
+    @overload
+    def number_input(
+        self,
+        label: str,
+        min_value: int | None = None,
+        max_value: int | None = None,
+        *,
+        value: int,
+        step: int | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, placeholder: str | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> int:
+        ...
+
+    # If "step=int" is given and all other numerical inputs are "int"s
+    #   or not provided (value optionally being "min"), return "int"
+    # If "step=int, value=None" is given and all other numerical inputs
+    #   are "int"s or not provided, return "int | None"
+    @overload
+    def number_input(
+        self,
+        label: str,
+        min_value: int | None = None,
+        max_value: int | None = None,
+        value: IntOrNone | Literal["min"] = "min",
+        *,
+        step: int,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, placeholder: str | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> int | IntOrNone:
+        ...
+
+    # If all numerical inputs are floats (with value optionally being "min")
+    #   or are not provided, return "float"
+    # If only "value=None" is given and none of the other numerical inputs
+    #   are "int"s, return "float | None"
+    @overload
+    def number_input(
+        self,
+        label: str,
+        min_value: float | None = None,
+        max_value: float | None = None,
+        value: FloatOrNone | Literal["min"] = "min",
+        step: float | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, placeholder: str | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> float | FloatOrNone:
+        ...
+    # # fmt: on
 
     @gather_metrics("number_input")
     def number_input(

streamlit/elements/widgets/selectbox.py

@@ -15,7 +15,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Callable, Generic, Sequence, cast
+from typing import TYPE_CHECKING, Any, Callable, Generic, Sequence, cast, overload
 
 from streamlit.dataframe_util import OptionSequence, convert_anything_to_sequence
 from streamlit.elements.form import current_form_id
@@ -74,6 +74,42 @@ class SelectboxSerde(Generic[T]):
 
 
 class SelectboxMixin:
+    @overload
+    def selectbox(
+        self,
+        label: str,
+        options: OptionSequence[T],
+        index: int = 0,
+        format_func: Callable[[Any], Any] = str,
+        key: Key | None = None,
+        help: str | None = None,
+        on_change: WidgetCallback | None = None,
+        args: WidgetArgs | None = None,
+        kwargs: WidgetKwargs | None = None,
+        *,  # keyword-only arguments:
+        placeholder: str = "Choose an option",
+        disabled: bool = False,
+        label_visibility: LabelVisibility = "visible",
+    ) -> T: ...
+
+    @overload
+    def selectbox(
+        self,
+        label: str,
+        options: OptionSequence[T],
+        index: None,
+        format_func: Callable[[Any], Any] = str,
+        key: Key | None = None,
+        help: str | None = None,
+        on_change: WidgetCallback | None = None,
+        args: WidgetArgs | None = None,
+        kwargs: WidgetKwargs | None = None,
+        *,  # keyword-only arguments:
+        placeholder: str = "Choose an option",
+        disabled: bool = False,
+        label_visibility: LabelVisibility = "visible",
+    ) -> T | None: ...
+
     @gather_metrics("selectbox")
     def selectbox(
         self,

streamlit/elements/widgets/slider.py

@@ -18,7 +18,18 @@ from dataclasses import dataclass
 from datetime import date, datetime, time, timedelta, timezone, tzinfo
 from numbers import Integral, Real
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Final, Sequence, Tuple, TypeVar, Union, cast
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Final,
+    List,
+    Sequence,
+    Tuple,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
 
 from typing_extensions import TypeAlias
 
@@ -50,14 +61,31 @@ from streamlit.runtime.state.common import compute_widget_id
 if TYPE_CHECKING:
     from streamlit.delta_generator import DeltaGenerator
 
-SliderScalarT = TypeVar("SliderScalarT", int, float, date, time, datetime)
+SliderNumericT = TypeVar("SliderNumericT", int, float)
+SliderDatelikeT = TypeVar("SliderDatelikeT", date, time, datetime)
 
-Step: TypeAlias = Union[int, float, timedelta]
-SliderScalar: TypeAlias = Union[int, float, date, time, datetime]
+SliderNumericSpanT: TypeAlias = Union[
+    List[SliderNumericT],
+    Tuple[()],
+    Tuple[SliderNumericT],
+    Tuple[SliderNumericT, SliderNumericT],
+]
+SliderDatelikeSpanT: TypeAlias = Union[
+    List[SliderDatelikeT],
+    Tuple[()],
+    Tuple[SliderDatelikeT],
+    Tuple[SliderDatelikeT, SliderDatelikeT],
+]
 
+StepNumericT: TypeAlias = SliderNumericT
+StepDatelikeT: TypeAlias = timedelta
+
+SliderStep = Union[int, float, timedelta]
+SliderScalar = Union[int, float, date, time, datetime]
+SliderValueT = TypeVar("SliderValueT", int, float, date, time, datetime)
 SliderValueGeneric: TypeAlias = Union[
-    SliderScalarT,
-    Sequence[SliderScalarT],
+    SliderValueT,
+    Sequence[SliderValueT],
 ]
 SliderValue: TypeAlias = Union[
     SliderValueGeneric[int],
@@ -66,11 +94,10 @@ SliderValue: TypeAlias = Union[
     SliderValueGeneric[time],
     SliderValueGeneric[datetime],
 ]
-
 SliderReturnGeneric: TypeAlias = Union[
-    SliderScalarT,
-    Tuple[SliderScalarT],
-    Tuple[SliderScalarT, SliderScalarT],
+    SliderValueT,
+    Tuple[SliderValueT],
+    Tuple[SliderValueT, SliderValueT],
 ]
 SliderReturn: TypeAlias = Union[
     SliderReturnGeneric[int],
@@ -166,14 +193,152 @@ class SliderSerde:
 
 
 class SliderMixin:
-    @gather_metrics("slider")
+    # For easier readability, all the arguments with un-changing types across these overload signatures have been
+    # collapsed onto a single line.
+
+    # fmt: off
+    # If min/max/value/step are not provided, then we return an int.
+    # if ONLY step is provided, then it must be an int and we return an int.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: None = None,
+        max_value: None = None,
+        value:  None = None,
+        step: int | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> int:
+        ...
+
+    # If min-value or max_value is provided and a numeric type, and value (if provided)
+    #   is a singular numeric, return the same numeric type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderNumericT | None = None,
+        max_value: SliderNumericT | None = None,
+        value: SliderNumericT | None = None,
+        step: StepNumericT[SliderNumericT] | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> SliderNumericT:
+        ...
+
+    # If value is provided and a sequence of numeric type,
+    #   return a tuple of the same numeric type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderNumericT | None = None,
+        max_value: SliderNumericT | None = None,
+        *,
+        value: SliderNumericSpanT[SliderNumericT],
+        step: StepNumericT[SliderNumericT] | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> tuple[SliderNumericT, SliderNumericT]:
+        ...
+
+    # If value is provided positionally and a sequence of numeric type,
+    #   return a tuple of the same numeric type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderNumericT,
+        max_value: SliderNumericT,
+        value: SliderNumericSpanT[SliderNumericT],
+        /,
+        step: StepNumericT[SliderNumericT] | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> tuple[SliderNumericT, SliderNumericT]:
+        ...
+
+    # If min-value is provided and a datelike type, and value (if provided)
+    #   is a singular datelike, return the same datelike type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderDatelikeT,
+        max_value: SliderDatelikeT | None = None,
+        value: SliderDatelikeT | None = None,
+        step: StepDatelikeT | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> SliderDatelikeT:
+        ...
+
+    # If max-value is provided and a datelike type, and value (if provided)
+    #   is a singular datelike, return the same datelike type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderDatelikeT | None = None,
+        *,
+        max_value: SliderDatelikeT,
+        value: SliderDatelikeT | None = None,
+        step: StepDatelikeT | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> SliderDatelikeT:
+        ...
+
+    # If value is provided and a datelike type, return the same datelike type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderDatelikeT | None = None,
+        max_value: SliderDatelikeT | None = None,
+        *,
+        value: SliderDatelikeT,
+        step: StepDatelikeT | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> SliderDatelikeT:
+        ...
+
+    # If value is provided and a sequence of datelike type,
+    #   return a tuple of the same datelike type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderDatelikeT | None = None,
+        max_value: SliderDatelikeT | None = None,
+        *,
+        value: SliderDatelikeSpanT[SliderDatelikeT],
+        step: StepDatelikeT | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> tuple[SliderDatelikeT, SliderDatelikeT]:
+        ...
+
+    # If value is provided positionally and a sequence of datelike type,
+    #   return a tuple of the same datelike type.
+    @overload
+    def slider(
+        self,
+        label: str,
+        min_value: SliderDatelikeT,
+        max_value: SliderDatelikeT,
+        value: SliderDatelikeSpanT[SliderDatelikeT],
+        /,
+        step: StepDatelikeT | None = None,
+        format: str | None = None, key: Key | None = None, help: str | None = None, on_change: WidgetCallback | None = None, args: WidgetArgs | None = None, kwargs: WidgetKwargs | None = None, *, disabled: bool = False, label_visibility: LabelVisibility = "visible"
+    ) -> tuple[SliderDatelikeT, SliderDatelikeT]:
+        ...
+
+    # fmt: on
+
+    # https://github.com/python/mypy/issues/17614
+    @gather_metrics("slider")  # type: ignore[misc]
     def slider(
         self,
         label: str,
         min_value: SliderScalar | None = None,
         max_value: SliderScalar | None = None,
         value: SliderValue | None = None,
-        step: Step | None = None,
+        step: SliderStep | None = None,
         format: str | None = None,
         key: Key | None = None,
         help: str | None = None,
@@ -183,11 +348,6 @@ class SliderMixin:
         *,  # keyword-only arguments:
         disabled: bool = False,
         label_visibility: LabelVisibility = "visible",
-        # TODO(harahu): Add overload definitions. The return type is
-        #  `SliderReturn`, in reality, but the return type is left as `Any`
-        #  until we have proper overload definitions in place. Otherwise the
-        #  user would have to cast the return value more often than not, which
-        #  can be annoying.
     ) -> Any:
         r"""Display a slider widget.
 
@@ -360,7 +520,7 @@ class SliderMixin:
         min_value=None,
         max_value=None,
         value=None,
-        step: Step | None = None,
+        step=None,
         format: str | None = None,
         key: Key | None = None,
         help: str | None = None,
@@ -509,7 +669,7 @@ class SliderMixin:
         if max_value is None:
             max_value = DEFAULTS[data_type]["max_value"]
         if step is None:
-            step = cast(Step, DEFAULTS[data_type]["step"])
+            step = DEFAULTS[data_type]["step"]
             if data_type in (
                 SliderProto.DATETIME,
                 SliderProto.DATE,

streamlit/external/langchain/streamlit_callback_handler.py

@@ -31,20 +31,25 @@ the API *from LangChain itself*.
 This module is lazy-loaded.
 """
 
+# NOTE: We ignore all mypy import-not-found errors as top-level since
+# this module is optional and the langchain dependency is not installed
+# by default.
+# mypy: disable-error-code="import-not-found, unused-ignore, misc"
+
 from __future__ import annotations
 
 import time
 from enum import Enum
 from typing import TYPE_CHECKING, Any, NamedTuple
 
-from langchain.callbacks.base import (  # type: ignore[import-not-found, unused-ignore]
+from langchain.callbacks.base import (
     BaseCallbackHandler,
 )
 
 from streamlit.runtime.metrics_util import gather_metrics
 
 if TYPE_CHECKING:
-    from langchain.schema import (  # type: ignore[import-not-found, unused-ignore]
+    from langchain.schema import (
         AgentAction,
         AgentFinish,
         LLMResult,