streamlit 1.47.1__py3-none-any.whl → 1.48.1__py3-none-any.whl

streamlit/elements/widgets/file_uploader.py

@@ -296,6 +296,12 @@ class FileUploaderMixin:
               example, to only accept JPG/JPEG and PNG files, use
               ``["jpg", "jpeg", "png"]``.
 
+            .. note::
+                This is a best-effort check, but doesn't provide a
+                security guarantee against users uploading files of other types
+                or type extensions. The correct handling of uploaded files is
+                part of the app developer's responsibility.
+
         accept_multiple_files : bool
             Whether to accept more than one file in a submission. If this is
             ``False`` (default), the user can only submit one file at a time.
@@ -320,8 +326,8 @@ class FileUploaderMixin:
             An optional callback invoked when this file_uploader's value
             changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.

streamlit/elements/widgets/multiselect.py

@@ -16,7 +16,16 @@ from __future__ import annotations
 
 from collections.abc import Sequence
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, cast, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    Literal,
+    TypeVar,
+    cast,
+    overload,
+)
 
 from streamlit.dataframe_util import OptionSequence, convert_anything_to_list
 from streamlit.elements.lib.form_utils import current_form_id
@@ -51,7 +60,6 @@ from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.scriptrunner import ScriptRunContext, get_script_run_ctx
 from streamlit.runtime.state import register_widget
 from streamlit.type_util import (
-    T,
     is_iterable,
 )
 
@@ -66,6 +74,8 @@ if TYPE_CHECKING:
         WidgetKwargs,
     )
 
+T = TypeVar("T")
+
 
 class MultiSelectSerde(Generic[T]):
     options: Sequence[T]
@@ -245,7 +255,7 @@ class MultiSelectMixin:
 
         Parameters
         ----------
-        label: str
+        label : str
             A short label explaining to the user what this select widget is for.
             The label can optionally contain GitHub-flavored Markdown of the
             following types: Bold, Italics, Strikethroughs, Inline Code, Links,
@@ -267,27 +277,27 @@ class MultiSelectMixin:
             .. |st.markdown| replace:: ``st.markdown``
             .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown
 
-        options: Iterable
+        options : Iterable
             Labels for the select options in an ``Iterable``. This can be a
             ``list``, ``set``, or anything supported by ``st.dataframe``. If
             ``options`` is dataframe-like, the first column will be used. Each
             label will be cast to ``str`` internally by default.
 
-        default: Iterable of V, V, or None
+        default : Iterable of V, V, or None
             List of default values. Can also be a single value.
 
-        format_func: function
+        format_func : function
             Function to modify the display of the options. It receives
             the raw option as an argument and should output the label to be
             shown for that option. This has no impact on the return value of
             the command.
 
-        key: str or int
+        key : str or int
             An optional string or integer to use as the unique key for the widget.
             If this is omitted, a key will be generated for the widget
             based on its content. No two widgets may have the same key.
 
-        help: str or None
+        help : str or None
             A tooltip that gets displayed next to the widget label. Streamlit
             only displays the tooltip when ``label_visibility="visible"``. If
             this is ``None`` (default), no tooltip is displayed.
@@ -296,19 +306,19 @@ class MultiSelectMixin:
             including the Markdown directives described in the ``body``
             parameter of ``st.markdown``.
 
-        on_change: callable
+        on_change : callable
             An optional callback invoked when this widget's value changes.
 
-        args: tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
-        kwargs: dict
+        kwargs : dict
             An optional dict of kwargs to pass to the callback.
 
-        max_selections: int
+        max_selections : int
             The max selections that can be selected at a time.
 
-        placeholder: str or  None
+        placeholder : str or  None
             A string to display when no options are selected.
             If this is ``None`` (default), the widget displays placeholder text
             based on the widget's configuration:
@@ -323,17 +333,17 @@ class MultiSelectMixin:
               and ``accept_new_options=False``. The widget is also disabled in
               this case.
 
-        disabled: bool
+        disabled : bool
             An optional boolean that disables the multiselect widget if set
             to ``True``. The default is ``False``.
 
-        label_visibility: "visible", "hidden", or "collapsed"
+        label_visibility : "visible", "hidden", or "collapsed"
             The visibility of the label. The default is ``"visible"``. If this
             is ``"hidden"``, Streamlit displays an empty spacer instead of the
             label, which can help keep the widget aligned with other widgets.
             If this is ``"collapsed"``, Streamlit displays no label or spacer.
 
-        accept_new_options: bool
+        accept_new_options : bool
             Whether the user can add selections that aren't included in ``options``.
             If this is ``False`` (default), the user can only select from the
             items in ``options``. If this is ``True``, the user can enter new

streamlit/elements/widgets/number_input.py

@@ -317,8 +317,8 @@ class NumberInputMixin:
         on_change : callable
             An optional callback invoked when this number_input's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.

streamlit/elements/widgets/radio.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Callable, Generic, cast, overload
+from typing import TYPE_CHECKING, Any, Callable, Generic, TypeVar, cast, overload
 
 from typing_extensions import Never
 
@@ -52,7 +52,6 @@ from streamlit.runtime.state import (
     register_widget,
 )
 from streamlit.type_util import (
-    T,
     check_python_comparable,
 )
 
@@ -61,6 +60,8 @@ if TYPE_CHECKING:
 
     from streamlit.delta_generator import DeltaGenerator
 
+T = TypeVar("T")
+
 
 @dataclass
 class RadioSerde(Generic[T]):
@@ -228,8 +229,8 @@ class RadioMixin:
         on_change : callable
             An optional callback invoked when this radio's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.

streamlit/elements/widgets/select_slider.py

@@ -21,6 +21,7 @@ from typing import (
     Any,
     Callable,
     Generic,
+    TypeVar,
     cast,
     overload,
 )
@@ -57,7 +58,7 @@ from streamlit.runtime.state import (
     WidgetKwargs,
     register_widget,
 )
-from streamlit.type_util import T, check_python_comparable
+from streamlit.type_util import check_python_comparable
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
@@ -66,6 +67,8 @@ if TYPE_CHECKING:
     from streamlit.elements.lib.layout_utils import WidthWithoutContent
     from streamlit.runtime.state.common import RegisterWidgetResult
 
+T = TypeVar("T")
+
 
 def _is_range_value(value: T | Sequence[T]) -> TypeGuard[Sequence[T]]:
     return isinstance(value, (list, tuple))
@@ -94,7 +97,7 @@ class SelectSliderSerde(Generic[T]):
         # If the original value was a list/tuple, so will be the output (and vice versa)
         return return_value if self.is_range_value else return_value[0]
 
-    def _as_index_list(self, v: object) -> list[int]:
+    def _as_index_list(self, v: Any) -> list[int]:
         if _is_range_value(v):
             slider_value = [index_(self.options, val) for val in v]
             start, end = slider_value
@@ -228,8 +231,8 @@ class SelectSliderMixin:
         on_change : callable
             An optional callback invoked when this select_slider's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.
@@ -352,7 +355,7 @@ class SelectSliderMixin:
         if len(opt) == 0:
             raise StreamlitAPIException("The `options` argument needs to be non-empty")
 
-        def as_index_list(v: object) -> list[int]:
+        def as_index_list(v: Any) -> list[int]:
             if _is_range_value(v):
                 slider_value = [index_(opt, val) for val in v]
                 start, end = slider_value

streamlit/elements/widgets/selectbox.py

@@ -14,7 +14,16 @@
 from __future__ import annotations
 
 from textwrap import dedent
-from typing import TYPE_CHECKING, Any, Callable, Generic, Literal, cast, overload
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    Literal,
+    TypeVar,
+    cast,
+    overload,
+)
 
 from typing_extensions import Never
 
@@ -54,7 +63,6 @@ from streamlit.runtime.state import (
     register_widget,
 )
 from streamlit.type_util import (
-    T,
     check_python_comparable,
 )
 
@@ -63,6 +71,8 @@ if TYPE_CHECKING:
 
     from streamlit.delta_generator import DeltaGenerator
 
+T = TypeVar("T")
+
 
 class SelectboxSerde(Generic[T]):
     options: Sequence[T]
@@ -336,8 +346,8 @@ class SelectboxMixin:
         on_change : callable
             An optional callback invoked when this selectbox's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.

streamlit/elements/widgets/slider.py

@@ -555,8 +555,8 @@ class SliderMixin:
         on_change : callable
             An optional callback invoked when this slider's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.
@@ -723,8 +723,7 @@ class SliderMixin:
             )
 
         # Simplify future logic by always making value a list
-        if single_value:
-            value = [value]
+        prepared_value: Sequence[SliderScalar] = [value] if single_value else value  # ty: ignore[invalid-assignment]
 
         def value_to_generic_type(v: Any) -> SliderProto.DataType.ValueType:
             if isinstance(v, Integral):
@@ -736,26 +735,32 @@ class SliderMixin:
         def all_same_type(items: Any) -> bool:
             return len(set(map(value_to_generic_type, items))) < 2
 
-        if not all_same_type(value):
+        if not all_same_type(prepared_value):
             raise StreamlitAPIException(
                 "Slider tuple/list components must be of the same type.\n"
-                f"But were: {list(map(type, value))}"
+                f"But were: {list(map(type, prepared_value))}"
             )
 
         data_type = (
-            SliderProto.INT if len(value) == 0 else value_to_generic_type(value[0])
+            SliderProto.INT
+            if len(prepared_value) == 0
+            else value_to_generic_type(prepared_value[0])
         )
 
-        datetime_min = time.min
-        datetime_max = time.max
+        datetime_min: datetime | time = time.min
+        datetime_max: datetime | time = time.max
         if data_type == SliderProto.TIME:
-            datetime_min = time.min.replace(tzinfo=value[0].tzinfo)
-            datetime_max = time.max.replace(tzinfo=value[0].tzinfo)
+            prepared_value = cast("Sequence[time]", prepared_value)
+
+            datetime_min = time.min.replace(tzinfo=prepared_value[0].tzinfo)
+            datetime_max = time.max.replace(tzinfo=prepared_value[0].tzinfo)
         if data_type in (SliderProto.DATETIME, SliderProto.DATE):
-            datetime_min = value[0] - timedelta(days=14)
-            datetime_max = value[0] + timedelta(days=14)
+            prepared_value = cast("Sequence[datetime]", prepared_value)
+
+            datetime_min = prepared_value[0] - timedelta(days=14)
+            datetime_max = prepared_value[0] + timedelta(days=14)
 
-        defaults: Final = {
+        defaults: Final[dict[SliderProto.DataType.ValueType, dict[str, Any]]] = {
             SliderProto.INT: {
                 "min_value": 0,
                 "max_value": 100,
@@ -846,20 +851,20 @@ class SliderMixin:
         # Ensure that min <= value(s) <= max, adjusting the bounds as necessary.
         min_value = min(min_value, max_value)
         max_value = max(min_value, max_value)
-        if len(value) == 1:
-            min_value = min(value[0], min_value)
-            max_value = max(value[0], max_value)
-        elif len(value) == 2:
-            start, end = value
-            if start > end:
+        if len(prepared_value) == 1:
+            min_value = min(prepared_value[0], min_value)
+            max_value = max(prepared_value[0], max_value)
+        elif len(prepared_value) == 2:
+            start, end = prepared_value
+            if start > end:  # type: ignore[operator]
                 # Swap start and end, since they seem reversed
                 start, end = end, start
-                value = start, end
+                prepared_value = start, end
             min_value = min(start, min_value)
             max_value = max(end, max_value)
         else:
             # Empty list, so let's just use the outer bounds
-            value = [min_value, max_value]
+            prepared_value = [min_value, max_value]
 
         # Bounds checks. JSNumber produces human-readable exceptions that
         # we simply re-package as StreamlitAPIExceptions.
@@ -881,12 +886,20 @@ class SliderMixin:
         orig_tz = None
         # Convert dates or times into datetimes
         if data_type == SliderProto.TIME:
-            value = list(map(_time_to_datetime, value))
+            prepared_value = cast("Sequence[time]", prepared_value)
+            min_value = cast("time", min_value)
+            max_value = cast("time", max_value)
+
+            prepared_value = list(map(_time_to_datetime, prepared_value))
             min_value = _time_to_datetime(min_value)
             max_value = _time_to_datetime(max_value)
 
         if data_type == SliderProto.DATE:
-            value = list(map(_date_to_datetime, value))
+            prepared_value = cast("Sequence[date]", prepared_value)
+            min_value = cast("date", min_value)
+            max_value = cast("date", max_value)
+
+            prepared_value = list(map(_date_to_datetime, prepared_value))
             min_value = _date_to_datetime(min_value)
             max_value = _date_to_datetime(max_value)
 
@@ -900,17 +913,25 @@ class SliderMixin:
 
         # Now, convert to microseconds (so we can serialize datetime to a long)
         if data_type in TIMELIKE_TYPES:
+            prepared_value = cast("Sequence[datetime]", prepared_value)
+            min_value = cast("datetime", min_value)
+            max_value = cast("datetime", max_value)
+            step = cast("timedelta", step)
+
             # Restore times/datetimes to original timezone (dates are always naive)
             orig_tz = (
-                value[0].tzinfo
+                prepared_value[0].tzinfo
                 if data_type in (SliderProto.TIME, SliderProto.DATETIME)
                 else None
             )
 
-            value = list(map(_datetime_to_micros, value))
+            prepared_value = list(map(_datetime_to_micros, prepared_value))
             min_value = _datetime_to_micros(min_value)
             max_value = _datetime_to_micros(max_value)
-            step = _delta_to_micros(cast("timedelta", step))
+            step = _delta_to_micros(step)
+
+        # At this point, prepared_value is expected to be a list of floats:
+        prepared_value = cast("list[float]", prepared_value)
 
         # It would be great if we could guess the number of decimal places from
         # the `step` argument, but this would only be meaningful if step were a
@@ -922,7 +943,7 @@ class SliderMixin:
         slider_proto.id = element_id
         slider_proto.label = label
         slider_proto.format = format
-        slider_proto.default[:] = value
+        slider_proto.default[:] = prepared_value
         slider_proto.min = min_value
         slider_proto.max = max_value
         slider_proto.step = cast("float", step)
@@ -937,7 +958,12 @@ class SliderMixin:
         if help is not None:
             slider_proto.help = dedent(help)
 
-        serde = SliderSerde(value, data_type, single_value, orig_tz)
+        serde = SliderSerde(
+            prepared_value,
+            data_type,
+            single_value,
+            orig_tz,
+        )
 
         widget_state = register_widget(
             slider_proto.id,
@@ -953,16 +979,16 @@ class SliderMixin:
         if widget_state.value_changed:
             # Min/Max bounds checks when the value is updated.
             serialized_values = serde.serialize(widget_state.value)
-            for value in serialized_values:
+            for serialized_value in serialized_values:
                 # Use the deserialized values for more readable error messages for dates/times
-                deserialized_value = serde.deserialize_single_value(value)
+                deserialized_value = serde.deserialize_single_value(serialized_value)
 
-                if value < slider_proto.min:
+                if serialized_value < slider_proto.min:
                     raise StreamlitValueBelowMinError(
                         value=deserialized_value,
                         min_value=serde.deserialize_single_value(slider_proto.min),
                     )
-                if value > slider_proto.max:
+                if serialized_value > slider_proto.max:
                     raise StreamlitValueAboveMaxError(
                         value=deserialized_value,
                         max_value=serde.deserialize_single_value(slider_proto.max),

streamlit/elements/widgets/text_widgets.py

@@ -206,8 +206,8 @@ class TextWidgetsMixin:
         on_change : callable
             An optional callback invoked when this text input's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.
@@ -535,8 +535,8 @@ class TextWidgetsMixin:
         on_change : callable
             An optional callback invoked when this text_area's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.

streamlit/elements/widgets/time_widgets.py

@@ -420,8 +420,8 @@ class TimeWidgetsMixin:
         on_change : callable
             An optional callback invoked when this time_input's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.
@@ -753,8 +753,8 @@ class TimeWidgetsMixin:
         on_change : callable
             An optional callback invoked when this date_input's value changes.
 
-        args : tuple
-            An optional tuple of args to pass to the callback.
+        args : list or tuple
+            An optional list or tuple of args to pass to the callback.
 
         kwargs : dict
             An optional dict of kwargs to pass to the callback.

streamlit/elements/write.py

@@ -86,7 +86,8 @@ class WriteMixin:
             The generator or iterable to stream.
 
             If you pass an async generator, Streamlit will internally convert
-            it to a sync generator.
+            it to a sync generator. If the generator depends on a cached object
+            with async references, this can raise an error.
 
             .. note::
                 To use additional LLM libraries, you can create a wrapper to
@@ -208,7 +209,7 @@ class WriteMixin:
             if type_util.is_type(chunk, "langchain_core.messages.ai.AIMessageChunk"):
                 # Try to convert LangChain message chunk to a string:
                 try:
-                    chunk = chunk.content or ""  # noqa: PLW2901
+                    chunk = chunk.content or ""  # noqa: PLW2901 # type: ignore[possibly-unbound-attribute]
                 except AttributeError as err:
                     raise StreamlitAPIException(
                         "Failed to parse the LangChain AIMessageChunk. "
@@ -380,19 +381,19 @@ class WriteMixin:
 
         Oh, one more thing: ``st.write`` accepts chart objects too! For example:
 
-        >>> import streamlit as st
-        >>> import pandas as pd
-        >>> import numpy as np
         >>> import altair as alt
+        >>> import pandas as pd
+        >>> import streamlit as st
+        >>> from numpy.random import default_rng as rng
         >>>
-        >>> df = pd.DataFrame(np.random.randn(200, 3), columns=["a", "b", "c"])
-        >>> c = (
+        >>> df = pd.DataFrame(rng(0).standard_normal((200, 3)), columns=["a", "b", "c"])
+        >>> chart = (
         ...     alt.Chart(df)
         ...     .mark_circle()
         ...     .encode(x="a", y="b", size="c", color="c", tooltip=["a", "b", "c"])
         ... )
         >>>
-        >>> st.write(c)
+        >>> st.write(chart)
 
         ..  output::
             https://doc-vega-lite-chart.streamlit.app/

streamlit/env_util.py

@@ -19,7 +19,7 @@ import platform
 import re
 import sys
 
-SYSTEM = platform.system().lower()
+SYSTEM = platform.system().lower()  # ty: ignore[unresolved-attribute]
 IS_WINDOWS = SYSTEM == "windows"
 IS_DARWIN = SYSTEM == "darwin"
 IS_LINUX_OR_BSD = (SYSTEM == "linux") or ("bsd" in SYSTEM)

streamlit/errors.py

@@ -239,22 +239,38 @@ class StreamlitInvalidColumnSpecError(LocalizableStreamlitException):
 class StreamlitInvalidVerticalAlignmentError(LocalizableStreamlitException):
     """Exception raised when an invalid value is specified for vertical_alignment."""
 
-    def __init__(self, vertical_alignment: str) -> None:
+    def __init__(self, vertical_alignment: str, element_type: str) -> None:
         super().__init__(
-            'The `vertical_alignment` argument to `st.columns` must be `"top"`, `"center"`, or `"bottom"`. \n'
+            "The `vertical_alignment` argument to `{element_type}` must be "
+            '`"top"`, `"center"`, `"bottom"`, or `"distribute"`. \n'
             "The argument passed was {vertical_alignment}.",
             vertical_alignment=vertical_alignment,
+            element_type=element_type,
         )
 
 
 class StreamlitInvalidColumnGapError(LocalizableStreamlitException):
     """Exception raised when an invalid value is specified for gap."""
 
-    def __init__(self, gap: str) -> None:
+    def __init__(self, gap: str, element_type: str) -> None:
         super().__init__(
-            'The `gap` argument to `st.columns` must be `"small"`, `"medium"`, `"large"`, or `"none"`. \n'
+            'The `gap` argument to `{element_type}` must be `"small"`, `"medium"`, `"large"`, or `"none"`. \n'
             "The argument passed was {gap}.",
             gap=gap,
+            element_type=element_type,
+        )
+
+
+class StreamlitInvalidHorizontalAlignmentError(LocalizableStreamlitException):
+    """Exception raised when an invalid value is specified for horizontal_alignment."""
+
+    def __init__(self, horizontal_alignment: str, element_type: str) -> None:
+        super().__init__(
+            "The `horizontal_alignment` argument to `{element_type}` must be "
+            '`"left"`, `"center"`, `"right"`, or `"distribute"`. \n'
+            "The argument passed was {horizontal_alignment}.",
+            horizontal_alignment=horizontal_alignment,
+            element_type=element_type,
         )
 
 

streamlit/file_util.py

@@ -244,7 +244,7 @@ def normalize_path_join(*args: str) -> str:
     str
         The normalized path of the joined path.
     """
-    return os.path.normpath(os.path.join(*args))
+    return os.path.normpath(os.path.join(*args))  # ty: ignore[no-matching-overload]
 
 
 def get_main_script_directory(main_script: str) -> str:

streamlit/git_util.py

@@ -47,7 +47,7 @@ class GitRepo:
             self.repo = git.Repo(path, search_parent_directories=True)
             self.git_version = self.repo.git.version_info
 
-            if self.git_version >= MIN_GIT_VERSION:
+            if self.git_version is not None and self.git_version >= MIN_GIT_VERSION:
                 git_root = self.repo.git.rev_parse("--show-toplevel")
                 self.module = os.path.relpath(path, git_root)
         except Exception:

streamlit/logger.py

@@ -18,7 +18,7 @@ from __future__ import annotations
 
 import logging
 import sys
-from typing import Final
+from typing import Final, cast
 
 DEFAULT_LOG_MESSAGE: Final = "%(asctime)s %(levelname) -7s %(name)s: %(message)s"
 
@@ -61,7 +61,7 @@ def setup_formatter(logger: logging.Logger) -> None:
     """Set up the console formatter for a given logger."""
     # Deregister any previous console loggers.
     if hasattr(logger, "streamlit_console_handler"):
-        logger.removeHandler(logger.streamlit_console_handler)
+        logger.removeHandler(cast("logging.Handler", logger.streamlit_console_handler))
 
     logger.streamlit_console_handler = logging.StreamHandler()  # type: ignore[attr-defined]