streamlit 1.45.1__py3-none-any.whl → 1.46.1__py3-none-any.whl

streamlit/testing/v1/local_script_runner.py

@@ -43,12 +43,13 @@ class LocalScriptRunner(ScriptRunner):
         script_path: str,
         session_state: SafeSessionState,
         pages_manager: PagesManager,
-        args=None,
-        kwargs=None,
-    ):
+        args: Any = None,
+        kwargs: Any = None,
+    ) -> None:
         """Initializes the ScriptRunner for the given script_path."""
 
-        assert os.path.isfile(script_path), f"File not found at {script_path}"
+        if not os.path.isfile(script_path):
+            raise FileNotFoundError(f"File not found at {script_path}")
 
         self.forward_msg_queue = ForwardMsgQueue()
         self.script_path = script_path
@@ -73,13 +74,12 @@ class LocalScriptRunner(ScriptRunner):
         self.event_data: list[Any] = []
 
         def record_event(
-            sender: ScriptRunner | None, event: ScriptRunnerEvent, **kwargs
+            sender: ScriptRunner | None, event: ScriptRunnerEvent, **kwargs: Any
         ) -> None:
             # Assert that we're not getting unexpected `sender` params
             # from ScriptRunner.on_event
-            assert sender is None or sender == self, (
-                "Unexpected ScriptRunnerEvent sender!"
-            )
+            if sender is not None and sender != self:
+                raise RuntimeError("Unexpected ScriptRunnerEvent sender!")
 
             self.events.append(event)
             self.event_data.append(kwargs)
@@ -103,7 +103,7 @@ class LocalScriptRunner(ScriptRunner):
     def run(
         self,
         widget_state: WidgetStates | None = None,
-        query_params=None,
+        query_params: dict[str, Any] | None = None,
         timeout: float = 3,
         page_hash: str = "",
     ) -> ElementTree:
@@ -127,14 +127,10 @@ class LocalScriptRunner(ScriptRunner):
             self.start()
         require_widgets_deltas(self, timeout)
 
-        tree = parse_tree_from_messages(self.forward_msgs())
-        return tree
+        return parse_tree_from_messages(self.forward_msgs())
 
     def script_stopped(self) -> bool:
-        for e in self.events:
-            if e == ScriptRunnerEvent.SHUTDOWN:
-                return True
-        return False
+        return any(e == ScriptRunnerEvent.SHUTDOWN for e in self.events)
 
     def _on_script_finished(
         self, ctx: ScriptRunContext, event: ScriptRunnerEvent, premature_stop: bool

streamlit/testing/v1/util.py

@@ -15,13 +15,18 @@
 from __future__ import annotations
 
 from contextlib import contextmanager
-from typing import Any
+from typing import TYPE_CHECKING, Any, Callable
 
 from streamlit import config
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
 
 @contextmanager
-def patch_config_options(config_overrides: dict[str, Any]):
+def patch_config_options(
+    config_overrides: dict[str, Any],
+) -> Generator[None, None, None]:
     """A context manager that overrides config options. It can
     also be used as a function decorator.
 
@@ -43,10 +48,12 @@ def patch_config_options(config_overrides: dict[str, Any]):
         yield
 
 
-def build_mock_config_get_option(overrides_dict):
+def build_mock_config_get_option(
+    overrides_dict: dict[str, Any],
+) -> Callable[[str], Any]:
     orig_get_option = config.get_option
 
-    def mock_config_get_option(name):
+    def mock_config_get_option(name: str) -> Any:
         if name in overrides_dict:
             return overrides_dict[name]
         return orig_get_option(name)

streamlit/type_util.py

@@ -49,7 +49,7 @@ from streamlit.errors import StreamlitAPIException
 
 if TYPE_CHECKING:
     import graphviz
-    import sympy  # type: ignore
+    import sympy
     from plotly.graph_objs import Figure
     from pydeck import Deck
 
@@ -119,8 +119,7 @@ def is_type(obj: object, fqn_type_pattern: str | re.Pattern[str]) -> bool:
     fqn_type = get_fqn_type(obj)
     if isinstance(fqn_type_pattern, str):
         return fqn_type_pattern == fqn_type
-    else:
-        return fqn_type_pattern.match(fqn_type) is not None
+    return fqn_type_pattern.match(fqn_type) is not None
 
 
 def _is_type_instance(obj: object, type_to_check: str) -> bool:
@@ -161,7 +160,7 @@ def to_bytes(obj: BytesLike) -> bytes:
     """
     if isinstance(obj, bytearray):
         return bytes(obj)
-    elif isinstance(obj, bytes):
+    if isinstance(obj, bytes):
         return obj
 
     raise RuntimeError(f"{obj} is not convertible to bytes")
@@ -232,10 +231,10 @@ def is_graphviz_chart(
 ) -> TypeGuard[graphviz.Graph | graphviz.Digraph]:
     """True if input looks like a GraphViz chart."""
     return (
-        # GraphViz < 0.18
+        # In GraphViz < 0.18
         is_type(obj, "graphviz.dot.Graph")
         or is_type(obj, "graphviz.dot.Digraph")
-        # GraphViz >= 0.18
+        # In GraphViz >= 0.18
         or is_type(obj, "graphviz.graphs.Graph")
         or is_type(obj, "graphviz.graphs.Digraph")
         or is_type(obj, "graphviz.sources.Source")
@@ -263,16 +262,13 @@ def _is_probably_plotly_dict(obj: object) -> TypeGuard[dict[str, Any]]:
     if len(obj.keys()) == 0:
         return False
 
-    if any(k not in ["config", "data", "frames", "layout"] for k in obj.keys()):
+    if any(k not in ["config", "data", "frames", "layout"] for k in obj):
         return False
 
     if any(_is_plotly_obj(v) for v in obj.values()):
         return True
 
-    if any(_is_list_of_plotly_objs(v) for v in obj.values()):
-        return True
-
-    return False
+    return bool(any(_is_list_of_plotly_objs(v) for v in obj.values()))
 
 
 def is_delta_generator(obj: object) -> TypeGuard[DeltaGenerator]:
@@ -317,7 +313,7 @@ def is_pydeck(obj: object) -> TypeGuard[Deck]:
     return is_type(obj, "pydeck.bindings.deck.Deck")
 
 
-def is_pydantic_model(obj) -> bool:
+def is_pydantic_model(obj: object) -> bool:
     """True if input looks like a Pydantic model instance."""
 
     if isinstance(obj, type):

streamlit/url_util.py

@@ -91,7 +91,7 @@ def is_url(
 
         if result.scheme in ["http", "https"]:
             return bool(result.netloc)
-        elif result.scheme in ["mailto", "data"]:
+        if result.scheme in ["mailto", "data"]:
             return bool(result.path)
 
     except ValueError:

streamlit/user_info.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 from collections.abc import Iterator, Mapping
 from typing import (
     TYPE_CHECKING,
+    Any,
     Final,
     NoReturn,
     Union,
@@ -358,7 +359,7 @@ def _get_user_info() -> UserInfo:
     ctx = _get_script_run_ctx()
     if ctx is None:
         _LOGGER.warning(
-            "No script run context available. st.experimental_user will return an empty dictionary."
+            "No script run context available. st.user will return an empty dictionary."
         )
         return {}
 
@@ -486,13 +487,13 @@ class UserInfoProxy(Mapping[str, Union[str, bool, None]]):
         try:
             return _get_user_info()[key]
         except KeyError:
-            raise KeyError(f'st.experimental_user has no key "{key}".')
+            raise KeyError(f'st.user has no key "{key}".')
 
     def __getattr__(self, key: str) -> str | bool | None:
         try:
             return _get_user_info()[key]
         except KeyError:
-            raise AttributeError(f'st.experimental_user has no attribute "{key}".')
+            raise AttributeError(f'st.user has no attribute "{key}".')
 
     def __setattr__(self, name: str, value: str | None) -> NoReturn:
         raise StreamlitAPIException("st.user cannot be modified")
@@ -548,10 +549,10 @@ class DeprecatedUserInfoProxy(UserInfoProxy):
     Streamlit.
     """
 
-    def __getattribute__(self, name: str):
+    def __getattribute__(self, name: str) -> Any:
         maybe_show_deprecated_user_warning()
         return super().__getattribute__(name)
 
-    def __getitem__(self, key: str):
+    def __getitem__(self, key: str) -> Any:
         maybe_show_deprecated_user_warning()
         return super().__getitem__(key)

streamlit/util.py

@@ -27,7 +27,7 @@ def memoize(func: Callable[..., Any]) -> Callable[..., Any]:
     result: list[Any] = []
 
     @functools.wraps(func)
-    def wrapped_func():
+    def wrapped_func() -> Any:
         if not result:
             result.append(func())
         return result[0]
@@ -70,3 +70,27 @@ def calc_md5(s: bytes | str) -> str:
 
     h.update(b)
     return h.hexdigest()
+
+
+class AttributeDictionary(dict[Any, Any]):
+    """
+    A dictionary subclass that supports attribute-style access.
+
+    This class extends the functionality of a standard dictionary to allow items
+    to be accessed via attribute-style dot notation in addition to the traditional
+    key-based access. If a dictionary item is accessed and is itself a dictionary,
+    it is automatically wrapped in another `AttributeDictionary`, enabling recursive
+    attribute-style access.
+    """
+
+    def __getattr__(self, key: str) -> Any:
+        try:
+            item = self.__getitem__(key)
+            return AttributeDictionary(item) if isinstance(item, dict) else item
+        except KeyError as err:
+            raise AttributeError(
+                f"'{type(self).__name__}' object has no attribute '{key}'"
+            ) from err
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        self[name] = value

streamlit/vendor/pympler/asizeof.py

@@ -172,6 +172,7 @@ details.
 
 import sys
 import types as Types
+from typing import Any
 import warnings
 import weakref as Weakref
 from inspect import isbuiltin, isclass, iscode, isframe, isfunction, ismethod, ismodule
@@ -192,7 +193,7 @@ _ignored_modules = {
     "types",
     Exception.__module__,  # 'weakref'
     __name__,
-}  # inluding this very module
+}  # including this very module
 
 # Sizes of some primitive C types
 # XXX len(pack(T, 0)) == Struct(T).size == calcsize(T)
@@ -2586,7 +2587,7 @@ def asized(*objs, **opts):
     return t
 
 
-def asizeof(*objs, **opts):
+def asizeof(*objs: Any, **opts: Any) -> int:
     """Return the combined size (in bytes) of all objects passed
     as positional arguments.
 

streamlit/watcher/event_based_path_watcher.py

@@ -243,7 +243,7 @@ class WatchedPath:
         *,  # keyword-only arguments:
         glob_pattern: str | None = None,
         allow_nonexistent: bool = False,
-    ):
+    ) -> None:
         self.md5 = md5
         self.modification_time = modification_time
 
@@ -359,7 +359,26 @@ class _FolderEventHandler(events.FileSystemEventHandler):
 
         abs_changed_path = os.path.abspath(changed_path)
 
-        changed_path_info = self._watched_paths.get(abs_changed_path, None)
+        # To prevent a race condition, we hold a lock while accessing
+        # _watched_paths.
+        with self._lock:
+            # First check if the exact path is being watched
+            changed_path_info = self._watched_paths.get(abs_changed_path, None)
+
+            # If the exact path isn't found, check if it's inside any watched
+            # directories. This is necessary for the folder watching feature to
+            # detect changes to files within watched directories, not just the
+            # 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 we still haven't found a matching path, ignore this event
         if changed_path_info is None:
             _LOGGER.debug(
                 "Ignoring changed path %s.\nWatched_paths: %s",

streamlit/watcher/folder_black_list.py

@@ -46,7 +46,7 @@ class FolderBlackList:
 
     """
 
-    def __init__(self, folder_blacklist):
+    def __init__(self, folder_blacklist: list[str]) -> None:
         """Constructor.
 
         Parameters
@@ -67,7 +67,7 @@ class FolderBlackList:
     def __repr__(self) -> str:
         return util.repr_(self)
 
-    def is_blacklisted(self, filepath):
+    def is_blacklisted(self, filepath: str) -> bool:
         """Test if filepath is in the blacklist.
 
         Parameters

streamlit/watcher/local_sources_watcher.py

@@ -46,11 +46,12 @@ PathWatcher = None
 
 
 class LocalSourcesWatcher:
-    def __init__(self, pages_manager: PagesManager):
+    def __init__(self, pages_manager: PagesManager) -> None:
         self._pages_manager = pages_manager
         self._main_script_path = os.path.abspath(self._pages_manager.main_script_path)
+        self._watch_folders = config.get_option("server.folderWatchList")
         self._script_folder = os.path.dirname(self._main_script_path)
-        self._on_file_changed: list[Callable[[str], None]] = []
+        self._on_path_changed: list[Callable[[str], None]] = []
         self._is_closed = False
         self._cached_sys_modules: set[str] = set()
 
@@ -79,6 +80,21 @@ class LocalSourcesWatcher:
                     module_name=None,
                 )
 
+        # Add custom watch path if it exists
+
+        for watch_folder in self._watch_folders:
+            # check if it is folder
+            if not os.path.isdir(watch_folder):
+                _LOGGER.warning("Watch folder is not a directory: %s", watch_folder)
+                continue
+            _LOGGER.debug("Registering watch folder: %s", watch_folder)
+            if watch_folder not in self._watched_pages:
+                self._register_watcher(
+                    watch_folder,
+                    module_name=None,
+                    is_directory=True,
+                )
+
         for old_page_path in old_page_paths:
             # Only remove pages that are no longer valid files
             if old_page_path not in new_pages_paths and not os.path.isfile(
@@ -90,11 +106,22 @@ class LocalSourcesWatcher:
         self._watched_pages = self._watched_pages.union(new_pages_paths)
 
     def register_file_change_callback(self, cb: Callable[[str], None]) -> None:
-        self._on_file_changed.append(cb)
+        self._on_path_changed.append(cb)
 
-    def on_file_changed(self, filepath):
+    def on_path_changed(self, filepath: str) -> None:
+        _LOGGER.debug("Path changed: %s", filepath)
         if filepath not in self._watched_modules:
-            _LOGGER.error("Received event for non-watched file: %s", filepath)
+            # Check if this is a file in a watched directory
+            for watched_dir in self._watched_modules:
+                if (
+                    os.path.isdir(watched_dir)
+                    and os.path.commonpath([watched_dir, filepath]) == watched_dir
+                ):
+                    _LOGGER.info("File changed in watched directory: %s", filepath)
+                    for cb in self._on_path_changed:
+                        cb(filepath)
+                    return
+            _LOGGER.error("Received event for non-watched path: %s", filepath)
             return
 
         # Workaround:
@@ -113,17 +140,19 @@ class LocalSourcesWatcher:
             if wm.module_name is not None and wm.module_name in sys.modules:
                 del sys.modules[wm.module_name]
 
-        for cb in self._on_file_changed:
+        for cb in self._on_path_changed:
             cb(filepath)
 
-    def close(self):
+    def close(self) -> None:
         for wm in self._watched_modules.values():
             wm.watcher.close()
         self._watched_modules = {}
         self._watched_pages = set()
         self._is_closed = True
 
-    def _register_watcher(self, filepath, module_name):
+    def _register_watcher(
+        self, filepath: str, module_name: str | None, is_directory: bool = False
+    ) -> None:
         global PathWatcher  # noqa: PLW0603
         if PathWatcher is None:
             PathWatcher = get_default_path_watcher_class()
@@ -132,10 +161,19 @@ class LocalSourcesWatcher:
             return
 
         try:
+            # Instead of using **kwargs, explicitly pass the named parameters
+            glob_pattern = "**/*" if is_directory else None
+
             wm = WatchedModule(
-                watcher=PathWatcher(filepath, self.on_file_changed),
+                watcher=PathWatcher(
+                    filepath,
+                    self.on_path_changed,
+                    glob_pattern=glob_pattern,  # Pass as named parameter
+                    allow_nonexistent=False,
+                ),
                 module_name=module_name,
             )
+            self._watched_modules[filepath] = wm
         except PermissionError:
             # If you don't have permission to read this file, don't even add it
             # to watchers.
@@ -143,7 +181,7 @@ class LocalSourcesWatcher:
 
         self._watched_modules[filepath] = wm
 
-    def _deregister_watcher(self, filepath):
+    def _deregister_watcher(self, filepath: str) -> None:
         if filepath not in self._watched_modules:
             return
 
@@ -154,17 +192,17 @@ class LocalSourcesWatcher:
         wm.watcher.close()
         del self._watched_modules[filepath]
 
-    def _file_is_new(self, filepath):
+    def _file_is_new(self, filepath: str) -> bool:
         return filepath not in self._watched_modules
 
-    def _file_should_be_watched(self, filepath):
+    def _file_should_be_watched(self, filepath: str) -> bool:
         # Using short circuiting for performance.
         return self._file_is_new(filepath) and (
             file_util.file_is_in_folder_glob(filepath, self._script_folder)
             or file_util.file_in_pythonpath(filepath)
         )
 
-    def update_watched_modules(self):
+    def update_watched_modules(self) -> None:
         if self._is_closed:
             return
 
@@ -187,12 +225,12 @@ class LocalSourcesWatcher:
 
 
 def get_module_paths(module: ModuleType) -> set[str]:
-    paths_extractors = [
+    paths_extractors: list[Callable[[ModuleType], list[str | None]]] = [
         # https://docs.python.org/3/reference/datamodel.html
         # __file__ is the pathname of the file from which the module was loaded
         # if it was loaded from a file.
         # The __file__ attribute may be missing for certain types of modules
-        lambda m: [m.__file__],
+        lambda m: [m.__file__] if hasattr(m, "__file__") else [],
         # https://docs.python.org/3/reference/import.html#__spec__
         # The __spec__ attribute is set to the module spec that was used
         # when importing the module. one exception is __main__,
@@ -202,12 +240,20 @@ def get_module_paths(module: ModuleType) -> set[str]:
         # (or resource within a system) from which a module originates
         # ... It is up to the loader to decide on how to interpret
         # and use a module's origin, if at all.
-        lambda m: [m.__spec__.origin],
+        lambda m: [m.__spec__.origin]
+        if hasattr(m, "__spec__") and m.__spec__ is not None
+        else [],
         # https://www.python.org/dev/peps/pep-0420/
         # Handling of "namespace packages" in which the __path__ attribute
         # is a _NamespacePath object with a _path attribute containing
         # the various paths of the package.
-        lambda m: list(m.__path__._path),
+        lambda m: list(m.__path__._path)
+        if hasattr(m, "__path__")
+        # This check prevents issues with torch classes:
+        # https://github.com/streamlit/streamlit/issues/10992
+        and type(m.__path__).__name__ == "_NamespacePath"
+        and hasattr(m.__path__, "_path")
+        else [],
     ]
 
     all_paths = set()
@@ -220,7 +266,7 @@ def get_module_paths(module: ModuleType) -> set[str]:
             pass
         except Exception:
             _LOGGER.warning(
-                f"Examining the path of {module.__name__} raised:", exc_info=True
+                "Examining the path of %s raised:", module.__name__, exc_info=True
             )
 
         all_paths.update(

streamlit/watcher/path_watcher.py

@@ -38,7 +38,7 @@ class NoOpPathWatcher:
         *,  # keyword-only arguments:
         glob_pattern: str | None = None,
         allow_nonexistent: bool = False,
-    ):
+    ) -> None:
         pass
 
 
@@ -62,7 +62,7 @@ def _is_watchdog_available() -> bool:
         return False
 
 
-def report_watchdog_availability():
+def report_watchdog_availability() -> None:
     if (
         config.get_option("server.fileWatcherType") not in ["poll", "none"]
         and not _is_watchdog_available()
@@ -70,15 +70,14 @@ def report_watchdog_availability():
         msg = "\n  $ xcode-select --install" if env_util.IS_DARWIN else ""
 
         cli_util.print_to_cli(
-            "  %s" % "For better performance, install the Watchdog module:",
+            "  For better performance, install the Watchdog module:",
             fg="blue",
             bold=True,
         )
         cli_util.print_to_cli(
-            """%s
+            f"""{msg}
   $ pip install watchdog
             """
-            % msg
         )
 
 
@@ -177,9 +176,6 @@ def get_path_watcher_class(watcher_type: str) -> PathWatcherType:
         from streamlit.watcher.event_based_path_watcher import EventBasedPathWatcher
 
         return EventBasedPathWatcher
-    elif watcher_type == "auto":
-        return PollingPathWatcher
-    elif watcher_type == "poll":
+    if watcher_type in {"auto", "poll"}:
         return PollingPathWatcher
-    else:
-        return NoOpPathWatcher
+    return NoOpPathWatcher

streamlit/watcher/polling_path_watcher.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 
 import time
 from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
 from typing import Callable, Final
 
 from streamlit.logger import get_logger
@@ -59,7 +60,7 @@ class PollingPathWatcher:
         retains references to all active instances.)
         """
         # TODO(vdonato): Modernize this by switching to pathlib.
-        self._path = path
+        self._path = Path(path)  # Changed to pathlib.Path
         self._on_changed = on_changed
 
         self._glob_pattern = glob_pattern
@@ -68,10 +69,10 @@ class PollingPathWatcher:
         self._active = True
 
         self._modification_time = util.path_modification_time(
-            self._path, self._allow_nonexistent
+            str(self._path), self._allow_nonexistent
         )
         self._md5 = util.calc_md5_with_blocking_retries(
-            self._path,
+            str(self._path),
             glob_pattern=self._glob_pattern,
             allow_nonexistent=self._allow_nonexistent,
         )
@@ -81,7 +82,7 @@ class PollingPathWatcher:
         return repr_(self)
 
     def _schedule(self) -> None:
-        def task():
+        def task() -> None:
             time.sleep(_POLLING_PERIOD_SECS)
             self._check_if_path_changed()
 
@@ -93,7 +94,7 @@ class PollingPathWatcher:
             return
 
         modification_time = util.path_modification_time(
-            self._path, self._allow_nonexistent
+            str(self._path), self._allow_nonexistent
         )
         # We add modification_time != 0.0 check since on some file systems (s3fs/fuse)
         # modification_time is always 0.0 because of file system limitations.
@@ -104,7 +105,7 @@ class PollingPathWatcher:
         self._modification_time = modification_time
 
         md5 = util.calc_md5_with_blocking_retries(
-            self._path,
+            str(self._path),
             glob_pattern=self._glob_pattern,
             allow_nonexistent=self._allow_nonexistent,
         )
@@ -115,7 +116,7 @@ class PollingPathWatcher:
         self._md5 = md5
 
         _LOGGER.debug("Change detected: %s", self._path)
-        self._on_changed(self._path)
+        self._on_changed(str(self._path))
 
         self._schedule()
 

streamlit/watcher/util.py

@@ -23,11 +23,14 @@ from __future__ import annotations
 import os
 import time
 from pathlib import Path
-from typing import Callable, TypeVar
+from typing import TYPE_CHECKING, Callable, TypeVar
 
 from streamlit.errors import Error
 from streamlit.util import calc_md5
 
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
 # How many times to try to grab the MD5 hash.
 _MAX_RETRIES = 5
 
@@ -170,17 +173,15 @@ def _do_with_retries(
     for i in _retry_dance():
         try:
             return orig_fn()
-        except exceptions:
+        except exceptions:  # noqa: PERF203
             if i >= _MAX_RETRIES - 1:
                 raise
-            else:
-                # Continue with loop to either retry or raise MaxRetriesError.
-                pass
+            # Continue with loop to either retry or raise MaxRetriesError.
 
     raise MaxRetriesError(f"Unable to access file or folder: {path}")
 
 
-def _retry_dance():
+def _retry_dance() -> Generator[int, None, None]:
     """Helper for writing a retry loop.
 
     This is useful to make sure all our retry loops work the same way. For example,