streamlit 1.50.0__py3-none-any.whl → 1.52.0__py3-none-any.whl

streamlit/testing/v1/app_test.py

@@ -18,7 +18,7 @@ import tempfile
 import textwrap
 import traceback
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 from unittest.mock import MagicMock
 from urllib import parse
 
@@ -48,6 +48,7 @@ from streamlit.testing.v1.element_tree import (
     Column,
     Dataframe,
     DateInput,
+    DateTimeInput,
     Divider,
     ElementList,
     ElementTree,
@@ -88,7 +89,7 @@ from streamlit.testing.v1.util import patch_config_options
 from streamlit.util import calc_md5
 
 if TYPE_CHECKING:
-    from collections.abc import Iterator, Sequence
+    from collections.abc import Callable, Iterator, Sequence
 
     from streamlit.proto.WidgetStates_pb2 import WidgetStates
 
@@ -608,6 +609,20 @@ class AppTest:
         """
         return self._tree.date_input
 
+    @property
+    def datetime_input(self) -> WidgetList[DateTimeInput]:
+        """Sequence of all ``st.datetime_input`` widgets.
+
+        Returns
+        -------
+        WidgetList of DateTimeInput
+            Sequence of all ``st.datetime_input`` widgets. Individual widgets can
+            be accessed from a WidgetList by index (order on the page) or key.
+            For example, ``at.datetime_input[0]`` for the first widget or
+            ``at.datetime_input(key="my_key")`` for a widget with a given key.
+        """
+        return self._tree.datetime_input
+
     @property
     def divider(self) -> ElementList[Divider]:
         """Sequence of all ``st.divider`` elements.

streamlit/testing/v1/element_tree.py

@@ -19,21 +19,20 @@ from __future__ import annotations
 
 import textwrap
 from abc import ABC, abstractmethod
-from collections.abc import Iterator, Sequence
+from collections.abc import Callable, Iterator, Sequence
 from dataclasses import dataclass, field, fields, is_dataclass
 from datetime import date, datetime, time, timedelta
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
     Generic,
+    TypeAlias,
     TypeVar,
-    Union,
     cast,
     overload,
 )
 
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from streamlit import dataframe_util, util
 from streamlit.elements.heading import HeadingProtoTag
@@ -41,6 +40,7 @@ from streamlit.elements.widgets.select_slider import SelectSliderSerde
 from streamlit.elements.widgets.slider import SliderSerde, SliderStep
 from streamlit.elements.widgets.time_widgets import (
     DateInputSerde,
+    DateTimeInputSerde,
     DateWidgetReturn,
     TimeInputSerde,
     _parse_date_value,
@@ -63,6 +63,7 @@ if TYPE_CHECKING:
     from streamlit.proto.Code_pb2 import Code as CodeProto
     from streamlit.proto.ColorPicker_pb2 import ColorPicker as ColorPickerProto
     from streamlit.proto.DateInput_pb2 import DateInput as DateInputProto
+    from streamlit.proto.DateTimeInput_pb2 import DateTimeInput as DateTimeInputProto
     from streamlit.proto.Element_pb2 import Element as ElementProto
     from streamlit.proto.Exception_pb2 import Exception as ExceptionProto
     from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
@@ -73,6 +74,7 @@ if TYPE_CHECKING:
     from streamlit.proto.NumberInput_pb2 import NumberInput as NumberInputProto
     from streamlit.proto.Radio_pb2 import Radio as RadioProto
     from streamlit.proto.Selectbox_pb2 import Selectbox as SelectboxProto
+    from streamlit.proto.Space_pb2 import Space as SpaceProto
     from streamlit.proto.Text_pb2 import Text as TextProto
     from streamlit.proto.TextArea_pb2 import TextArea as TextAreaProto
     from streamlit.proto.TextInput_pb2 import TextInput as TextInputProto
@@ -505,8 +507,8 @@ class Dataframe(Element):
         return dataframe_util.convert_arrow_bytes_to_pandas_df(self.proto.data)
 
 
-SingleDateValue: TypeAlias = Union[date, datetime]
-DateValue: TypeAlias = Union[SingleDateValue, Sequence[SingleDateValue], None]
+SingleDateValue: TypeAlias = date | datetime
+DateValue: TypeAlias = SingleDateValue | Sequence[SingleDateValue] | None
 
 
 @dataclass(repr=False)
@@ -670,6 +672,20 @@ class Latex(Markdown):
         self.type = "latex"
 
 
+@dataclass(repr=False)
+class Space(Element):
+    """A representation of st.space for testing."""
+
+    proto: SpaceProto = field(repr=False)
+
+    key: None = None
+
+    def __init__(self, proto: SpaceProto, root: ElementTree) -> None:
+        self.proto = proto
+        self.root = root
+        self.type = "space"
+
+
 @dataclass(repr=False)
 class Metric(Element):
     proto: MetricProto
@@ -861,7 +877,7 @@ class Multiselect(Widget, Generic[T]):
         return self
 
 
-Number = Union[int, float]
+Number: TypeAlias = int | float
 
 
 @dataclass(repr=False)
@@ -1308,7 +1324,8 @@ class TextInput(Widget):
         return self.set_value(v)
 
 
-TimeValue: TypeAlias = Union[time, datetime]
+TimeValue: TypeAlias = time | datetime
+DateTimeWidgetValue: TypeAlias = datetime
 
 
 @dataclass(repr=False)
@@ -1368,6 +1385,59 @@ class TimeInput(Widget):
         return self.set_value(dt.time())
 
 
+@dataclass(repr=False)
+class DateTimeInput(Widget):
+    """A representation of ``st.datetime_input``."""
+
+    _value: DateTimeWidgetValue | None | InitialValue
+    proto: DateTimeInputProto = field(repr=False)
+    label: str
+    format: str
+    min: str
+    max: str
+    step: int
+    help: str
+    form_id: str
+
+    def __init__(self, proto: DateTimeInputProto, root: ElementTree) -> None:
+        super().__init__(proto, root)
+        self._value = InitialValue()
+        self.type = "date_time_input"
+
+    def set_value(self, v: DateTimeWidgetValue | None) -> DateTimeInput:
+        """Set the value of the widget."""
+        self._value = v
+        return self
+
+    @property
+    def _widget_state(self) -> WidgetState:
+        from datetime import datetime
+
+        datetime_ui_format = "%Y/%m/%d, %H:%M"
+
+        ws = WidgetState()
+        ws.id = self.id
+
+        # Parse min and max values for validation
+        min_dt = datetime.strptime(self.min, datetime_ui_format)
+        max_dt = datetime.strptime(self.max, datetime_ui_format)
+
+        serde = DateTimeInputSerde(value=None, min=min_dt, max=max_dt)
+        serialized_value = serde.serialize(self.value)
+        if serialized_value is not None:
+            ws.string_array_value.data[:] = serialized_value
+        return ws
+
+    @property
+    def value(self) -> datetime | None:
+        """The current value of the widget. (datetime)"""  # noqa: D400
+        if not isinstance(self._value, InitialValue):
+            return self._value
+        state = self.root.session_state
+        assert state
+        return state[self.id]  # type: ignore
+
+
 @dataclass(repr=False)
 class Toast(Element):
     proto: ToastProto = field(repr=False)
@@ -1518,6 +1588,10 @@ class Block:
     def date_input(self) -> WidgetList[DateInput]:
         return WidgetList(self.get("date_input"))  # type: ignore
 
+    @property
+    def datetime_input(self) -> WidgetList[DateTimeInput]:
+        return WidgetList(self.get("date_time_input"))  # type: ignore
+
     @property
     def divider(self) -> ElementList[Divider]:
         return ElementList(self.get("divider"))  # type: ignore
@@ -1828,7 +1902,7 @@ class Tab(Block):
         self.label = proto.label
 
 
-Node: TypeAlias = Union[Element, Block]
+Node: TypeAlias = Element | Block
 
 
 def get_widget_state(node: Node) -> WidgetState | None:
@@ -1972,6 +2046,8 @@ def parse_tree_from_messages(messages: list[ForwardMsg]) -> ElementTree:
                 new_node = ColorPicker(elt.color_picker, root=root)
             elif ty == "date_input":
                 new_node = DateInput(elt.date_input, root=root)
+            elif ty == "date_time_input":
+                new_node = DateTimeInput(elt.date_time_input, root=root)
             elif ty == "exception":
                 new_node = Exception(elt.exception, root=root)
             elif ty == "heading":

streamlit/testing/v1/util.py

@@ -15,12 +15,12 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from streamlit import config
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
 
 
 @contextmanager

streamlit/type_util.py

@@ -38,12 +38,11 @@ from typing import (
     Literal,
     NamedTuple,
     Protocol,
-    Union,
+    TypeAlias,
+    TypeGuard,
     overload,
 )
 
-from typing_extensions import TypeAlias, TypeGuard
-
 from streamlit.errors import StreamlitAPIException
 
 if TYPE_CHECKING:
@@ -149,7 +148,7 @@ _BYTES_LIKE_TYPES: Final[tuple[type, ...]] = (
     bytearray,
 )
 
-BytesLike: TypeAlias = Union[bytes, bytearray]
+BytesLike: TypeAlias = bytes | bytearray
 
 
 def is_bytes_like(obj: object) -> TypeGuard[BytesLike]:

streamlit/url_util.py

@@ -15,11 +15,9 @@
 from __future__ import annotations
 
 import re
-from typing import Final, Literal
+from typing import Final, Literal, TypeAlias
 from urllib.parse import urlparse
 
-from typing_extensions import TypeAlias
-
 UrlSchema: TypeAlias = Literal["http", "https", "mailto", "data"]
 
 

streamlit/user_info.py

@@ -20,7 +20,6 @@ from typing import (
     Any,
     Final,
     NoReturn,
-    Union,
 )
 
 from streamlit import config, logger, runtime
@@ -379,7 +378,7 @@ def _get_user_info() -> UserInfo:
     return context_user_info
 
 
-class UserInfoProxy(Mapping[str, Union[str, bool, None]]):
+class UserInfoProxy(Mapping[str, str | bool | None]):
     """
     A read-only, dict-like object for accessing information about the current\
     user.

streamlit/util.py

@@ -19,11 +19,13 @@ from __future__ import annotations
 import dataclasses
 import functools
 import hashlib
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 from streamlit.proto.RootContainer_pb2 import RootContainer
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from streamlit.delta_generator import DeltaGenerator
 
 

streamlit/watcher/event_based_path_watcher.py

@@ -39,7 +39,7 @@ from __future__ import annotations
 
 import os
 import threading
-from typing import TYPE_CHECKING, Callable, Final, cast
+from typing import TYPE_CHECKING, Final, cast
 
 from blinker import ANY, Signal
 from typing_extensions import Self
@@ -52,6 +52,8 @@ from streamlit.util import repr_
 from streamlit.watcher import util
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
+
     from watchdog.observers.api import ObservedWatch
 
 _LOGGER: Final = get_logger(__name__)
@@ -372,11 +374,9 @@ class _FolderEventHandler(events.FileSystemEventHandler):
             _LOGGER.debug("Don't care about event type %s", event.event_type)
             return
 
-        # Watchdog 5.X is supported Python >=3.9, so watchdog 4.X is used for Python 3.8.
-        # In Watchdog 5.X, the path can be bytes or str, but in Watchdog 4.X, the path is always str,
-        # that's why we convert the path to str, but we need to ignore the unreachable code warning for Python 3.8.
-        if isinstance(changed_path, bytes):  # type: ignore[unreachable, unused-ignore]
-            changed_path = changed_path.decode("utf-8")  # type: ignore[unreachable, unused-ignore]
+        # Watchdog 5.X emits bytes paths on some platforms, so we normalize to str.
+        if isinstance(changed_path, bytes):
+            changed_path = changed_path.decode("utf-8")
 
         if changed_path.endswith("~"):
             # Files ending with ~ are typically backup files created by editors.
@@ -397,12 +397,23 @@ class _FolderEventHandler(events.FileSystemEventHandler):
             # directories themselves.
             if changed_path_info is None:
                 for path, info in self._watched_paths.items():
-                    if (
-                        os.path.isdir(path)
-                        and os.path.commonpath([path, abs_changed_path]) == path
-                    ):
-                        changed_path_info = info
-                        break
+                    if not os.path.isdir(path):
+                        continue
+                    try:
+                        if os.path.commonpath([path, abs_changed_path]) == path:
+                            changed_path_info = info
+                            break
+                    except ValueError as ex:
+                        # On Windows, os.path.commonpath raises ValueError when paths
+                        # are on different drives. In that case, the changed path
+                        # cannot be inside the watched directory.
+                        _LOGGER.debug(
+                            "Ignoring changed path %s.\nWatched_paths: %s",
+                            abs_changed_path,
+                            self._watched_paths,
+                            exc_info=ex,
+                        )
+                        continue
 
         # If we still haven't found a matching path, ignore this event
         if changed_path_info is None:

streamlit/watcher/local_sources_watcher.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 import os
 import sys
-from typing import TYPE_CHECKING, Any, Callable, Final, NamedTuple
+from typing import TYPE_CHECKING, Any, Final, NamedTuple
 
 from streamlit import config, file_util
 from streamlit.logger import get_logger
@@ -28,6 +28,7 @@ from streamlit.watcher.path_watcher import (
 )
 
 if TYPE_CHECKING:
+    from collections.abc import Callable
     from types import ModuleType
 
     from streamlit.runtime.pages_manager import PagesManager
@@ -46,6 +47,15 @@ PathWatcher: PathWatcherType | None = None
 
 
 class LocalSourcesWatcher:
+    """Watch local Python sources and pages to trigger app reruns.
+
+    Purpose
+    -------
+    This watcher powers Streamlit's core developer workflow: save a Python file
+    and the app reruns. It tracks Python modules, the main script directory, and
+    configured watch folders to notify the runtime when a relevant file changes.
+    """
+
     def __init__(self, pages_manager: PagesManager) -> None:
         self._pages_manager = pages_manager
         self._main_script_path = os.path.realpath(self._pages_manager.main_script_path)

streamlit/watcher/path_watcher.py

@@ -15,12 +15,15 @@
 from __future__ import annotations
 
 import os
-from typing import Callable, Union
+from typing import TYPE_CHECKING, TypeAlias
 
 import streamlit.watcher
 from streamlit import cli_util, config, env_util
 from streamlit.watcher.polling_path_watcher import PollingPathWatcher
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 
 # local_sources_watcher.py caches the return value of
 # get_default_path_watcher_class(), so it needs to differentiate between the
@@ -45,11 +48,11 @@ class NoOpPathWatcher:
 # EventBasedPathWatcher will be a stub and have no functional
 # implementation if its import failed (due to missing watchdog module),
 # so we can't reference it directly in this type.
-PathWatcherType = Union[
-    type["streamlit.watcher.event_based_path_watcher.EventBasedPathWatcher"],
-    type[PollingPathWatcher],
-    type[NoOpPathWatcher],
-]
+PathWatcherType: TypeAlias = (
+    type["streamlit.watcher.event_based_path_watcher.EventBasedPathWatcher"]
+    | type[PollingPathWatcher]
+    | type[NoOpPathWatcher]
+)
 
 
 def _is_watchdog_available() -> bool:

streamlit/watcher/polling_path_watcher.py

@@ -19,13 +19,16 @@ from __future__ import annotations
 import time
 from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
-from typing import Callable, Final
+from typing import TYPE_CHECKING, Final
 
 from streamlit.errors import StreamlitMaxRetriesError
 from streamlit.logger import get_logger
 from streamlit.util import repr_
 from streamlit.watcher import util
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 _LOGGER: Final = get_logger(__name__)
 
 _MAX_WORKERS: Final = 4

streamlit/watcher/util.py

@@ -23,13 +23,13 @@ from __future__ import annotations
 import os
 import time
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from streamlit.errors import StreamlitMaxRetriesError
 from streamlit.util import calc_md5
 
 if TYPE_CHECKING:
-    from collections.abc import Generator
+    from collections.abc import Callable, Generator
 
 # How many times to try to grab the MD5 hash.
 _MAX_RETRIES = 5

streamlit/web/bootstrap.py

@@ -58,6 +58,29 @@ def _fix_sys_path(main_script_path: str) -> None:
     sys.path.insert(0, os.path.dirname(main_script_path))
 
 
+def _maybe_install_uvloop(running_in_event_loop: bool) -> None:
+    """Install uvloop as the default event loop policy if available."""
+
+    if running_in_event_loop:
+        return
+
+    if env_util.IS_WINDOWS:
+        return
+
+    try:
+        import uvloop
+    except ModuleNotFoundError:
+        return
+
+    try:
+        uvloop.install()
+        _LOGGER.debug("uvloop installed as default event loop policy.")
+    except Exception:
+        _LOGGER.warning(
+            "Failed to install uvloop. Falling back to default loop.", exc_info=True
+        )
+
+
 def _fix_tornado_crash() -> None:
     """Set default asyncio policy to be compatible with Tornado 6.
 
@@ -326,6 +349,7 @@ def run(
         # This prevents the task from being garbage collected
         server._bootstrap_task = task
     else:
+        _maybe_install_uvloop(running_in_event_loop)
         # No running event loop, so we can use asyncio.run
         # This is the normal case when running streamlit from the command line
         _LOGGER.debug("Starting new event loop for server")

streamlit/web/cli.py

@@ -18,7 +18,9 @@ from __future__ import annotations
 
 import os
 import sys
-from typing import TYPE_CHECKING, Any, Callable, Final, TypeVar
+from collections.abc import Callable
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Final, TypeVar
 
 # We cannot lazy-load click here because its used via decorators.
 import click
@@ -195,46 +197,73 @@ def main_hello(**kwargs: Any) -> None:
 
 @main.command("run")
 @configurator_options
-@click.argument("target", required=True, envvar="STREAMLIT_RUN_TARGET")
+@click.argument("target", default="streamlit_app.py", envvar="STREAMLIT_RUN_TARGET")
 @click.argument("args", nargs=-1)
 def main_run(target: str, args: list[str] | None = None, **kwargs: Any) -> None:
     """Run a Python script, piping stderr to Streamlit.
 
-    The script can be local or it can be an url. In the latter case, Streamlit
-    will download the script to a temporary file and runs this file.
+    If omitted, the target script will be assumed to be "streamlit_app.py".
 
+    Otherwise, the target script should be one of the following:
+    - The path to a local Python file.
+    - The path to a local folder where "streamlit_app.py" can be found.
+    - A URL pointing to a Python file. In this case Streamlit will download the
+      file to a temporary file and run it.
+
+    To pass command-line arguments to the script, add " -- " before them. For example:
+
+        $ streamlit run my_app.py -- --my_arg1=123 my_arg2
+                                   ↑
+                                   Your CLI args start after this.
     """
     from streamlit import url_util
 
-    _, extension = os.path.splitext(target)
-    if extension[1:] not in ACCEPTED_FILE_EXTENSIONS:
-        if extension[1:] == "":
-            raise click.BadArgumentUsage(
-                "Streamlit requires raw Python (.py) files, but the provided file has no extension.\n"
-                "For more information, please see https://docs.streamlit.io"
-            )
-        raise click.BadArgumentUsage(
-            f"Streamlit requires raw Python (.py) files, not {extension}.\nFor more information, please see https://docs.streamlit.io"
-        )
-
     if url_util.is_url(target):
         from streamlit.temporary_directory import TemporaryDirectory
 
         with TemporaryDirectory() as temp_dir:
             from urllib.parse import urlparse
 
-            path = urlparse(target).path
+            url_subpath = urlparse(target).path
+
+            _check_extension_or_raise(url_subpath)
+
             main_script_path = os.path.join(
-                temp_dir, path.strip("/").rsplit("/", 1)[-1]
+                temp_dir, url_subpath.strip("/").rsplit("/", 1)[-1]
             )
             # if this is a GitHub/Gist blob url, convert to a raw URL first.
-            target = url_util.process_gitblob_url(target)
-            _download_remote(main_script_path, target)
+            url = url_util.process_gitblob_url(target)
+            _download_remote(main_script_path, url)
             _main_run(main_script_path, args, flag_options=kwargs)
+
     else:
-        if not os.path.exists(target):
-            raise click.BadParameter(f"File does not exist: {target}")
-        _main_run(target, args, flag_options=kwargs)
+        path = Path(target)
+
+        if path.is_dir():
+            path /= "streamlit_app.py"
+
+        path_str = str(path)
+        _check_extension_or_raise(path_str)
+
+        if not path.exists():
+            raise click.BadParameter(f"File does not exist: {path}")
+
+        _main_run(path_str, args, flag_options=kwargs)
+
+
+def _check_extension_or_raise(path_str: str) -> None:
+    _, extension = os.path.splitext(path_str)
+
+    if extension[1:] not in ACCEPTED_FILE_EXTENSIONS:
+        if extension[1:] == "":
+            raise click.BadArgumentUsage(
+                "Streamlit requires raw Python (.py) files, but the provided file has no extension.\n"
+                "For more information, please see https://docs.streamlit.io"
+            )
+        raise click.BadArgumentUsage(
+            f"Streamlit requires raw Python (.py) files, not {extension}.\n"
+            "For more information, please see https://docs.streamlit.io"
+        )
 
 
 def _get_command_line_as_string() -> str | None: