streamlit-nightly 1.35.1.dev20240530__py2.py3-none-any.whl → 1.35.1.dev20240601__py2.py3-none-any.whl

streamlit/runtime/app_session.py

@@ -21,7 +21,7 @@ from enum import Enum
 from typing import TYPE_CHECKING, Callable, Final
 
 import streamlit.elements.exception as exception_utils
-from streamlit import config, runtime, source_util
+from streamlit import config, runtime
 from streamlit.case_converters import to_snake_case
 from streamlit.logger import get_logger
 from streamlit.proto.BackMsg_pb2 import BackMsg
@@ -40,11 +40,13 @@ from streamlit.runtime import caching
 from streamlit.runtime.forward_msg_queue import ForwardMsgQueue
 from streamlit.runtime.fragment import FragmentStorage, MemoryFragmentStorage
 from streamlit.runtime.metrics_util import Installation
+from streamlit.runtime.pages_manager import PagesManager
 from streamlit.runtime.script_data import ScriptData
 from streamlit.runtime.scriptrunner import RerunData, ScriptRunner, ScriptRunnerEvent
 from streamlit.runtime.scriptrunner.script_cache import ScriptCache
 from streamlit.runtime.secrets import secrets_singleton
 from streamlit.runtime.uploaded_file_manager import UploadedFileManager
+from streamlit.source_util import PageHash, PageInfo
 from streamlit.version import STREAMLIT_VERSION_STRING
 from streamlit.watcher import LocalSourcesWatcher
 
@@ -127,6 +129,9 @@ class AppSession:
         self._script_data = script_data
         self._uploaded_file_mgr = uploaded_file_manager
         self._script_cache = script_cache
+        self._pages_manager = PagesManager(
+            script_data.main_script_path, self._script_cache
+        )
 
         # The browser queue contains messages that haven't yet been
         # delivered to the browser. Periodically, the server flushes
@@ -182,9 +187,7 @@ class AppSession:
         to.
         """
         if self._local_sources_watcher is None:
-            self._local_sources_watcher = LocalSourcesWatcher(
-                self._script_data.main_script_path
-            )
+            self._local_sources_watcher = LocalSourcesWatcher(self._pages_manager)
 
         self._local_sources_watcher.register_file_change_callback(
             self._on_source_file_changed
@@ -192,7 +195,7 @@ class AppSession:
         self._stop_config_listener = config.on_config_parsed(
             self._on_source_file_changed, force_connect=True
         )
-        self._stop_pages_listener = source_util.register_pages_changed_callback(
+        self._stop_pages_listener = self._pages_manager.register_pages_changed_callback(
             self._on_pages_changed
         )
         secrets_singleton.file_change_listener.connect(self._on_secrets_file_changed)
@@ -408,6 +411,7 @@ class AppSession:
             initial_rerun_data=initial_rerun_data,
             user_info=self._user_info,
             fragment_storage=self._fragment_storage,
+            pages_manager=self._pages_manager,
         )
         self._scriptrunner.on_event.connect(self._on_scriptrunner_event)
         self._scriptrunner.start()
@@ -417,8 +421,7 @@ class AppSession:
         return self._session_state
 
     def _should_rerun_on_file_change(self, filepath: str) -> bool:
-        main_script_path = self._script_data.main_script_path
-        pages = source_util.get_pages(main_script_path)
+        pages = self._pages_manager.get_pages()
 
         changed_page_script_hash = next(
             filter(lambda k: pages[k]["script_path"] == filepath, pages),
@@ -455,7 +458,7 @@ class AppSession:
 
     def _on_pages_changed(self, _) -> None:
         msg = ForwardMsg()
-        _populate_app_pages(msg.pages_changed, self._script_data.main_script_path)
+        self._populate_app_pages(msg.pages_changed, self._pages_manager.get_pages())
         self._enqueue_forward_msg(msg)
 
         if self._local_sources_watcher is not None:
@@ -473,6 +476,7 @@ class AppSession:
         client_state: ClientState | None = None,
         page_script_hash: str | None = None,
         fragment_ids_this_run: set[str] | None = None,
+        pages: dict[PageHash, PageInfo] | None = None,
     ) -> None:
         """Called when our ScriptRunner emits an event.
 
@@ -489,6 +493,7 @@ class AppSession:
                 client_state,
                 page_script_hash,
                 fragment_ids_this_run,
+                pages,
             )
         )
 
@@ -501,6 +506,7 @@ class AppSession:
         client_state: ClientState | None = None,
         page_script_hash: str | None = None,
         fragment_ids_this_run: set[str] | None = None,
+        pages: dict[PageHash, PageInfo] | None = None,
     ) -> None:
         """Handle a ScriptRunner event.
 
@@ -572,7 +578,7 @@ class AppSession:
 
             self._enqueue_forward_msg(
                 self._create_new_session_message(
-                    page_script_hash, fragment_ids_this_run
+                    page_script_hash, fragment_ids_this_run, pages
                 )
             )
 
@@ -603,6 +609,7 @@ class AppSession:
                 # that change which modules should be watched.
                 if self._local_sources_watcher:
                     self._local_sources_watcher.update_watched_modules()
+                    self._local_sources_watcher.update_watched_pages()
             else:
                 # The script didn't complete successfully: send the exception
                 # to the frontend.
@@ -666,20 +673,26 @@ class AppSession:
         return msg
 
     def _create_new_session_message(
-        self, page_script_hash: str, fragment_ids_this_run: set[str] | None = None
+        self,
+        page_script_hash: str,
+        fragment_ids_this_run: set[str] | None = None,
+        pages: dict[PageHash, PageInfo] | None = None,
     ) -> ForwardMsg:
         """Create and return a new_session ForwardMsg."""
         msg = ForwardMsg()
 
         msg.new_session.script_run_id = _generate_scriptrun_id()
         msg.new_session.name = self._script_data.name
-        msg.new_session.main_script_path = self._script_data.main_script_path
+        msg.new_session.main_script_path = self._pages_manager.main_script_path
+        msg.new_session.main_script_hash = self._pages_manager.main_script_hash
         msg.new_session.page_script_hash = page_script_hash
 
         if fragment_ids_this_run:
             msg.new_session.fragment_ids_this_run.extend(fragment_ids_this_run)
 
-        _populate_app_pages(msg.new_session, self._script_data.main_script_path)
+        self._populate_app_pages(
+            msg.new_session, pages or self._pages_manager.get_pages()
+        )
         _populate_config_msg(msg.new_session.config)
         _populate_theme_msg(msg.new_session.custom_theme)
 
@@ -829,6 +842,16 @@ class AppSession:
 
         self._enqueue_forward_msg(msg)
 
+    def _populate_app_pages(
+        self, msg: NewSession | PagesChanged, pages: dict[PageHash, PageInfo]
+    ) -> None:
+        for page_script_hash, page_info in pages.items():
+            page_proto = msg.app_pages.add()
+
+            page_proto.page_script_hash = page_script_hash
+            page_proto.page_name = page_info["page_name"]
+            page_proto.icon = page_info["icon"]
+
 
 # Config.ToolbarMode.ValueType does not exist at runtime (only in the pyi stubs), so
 # we need to use quotes.
@@ -913,12 +936,3 @@ def _populate_theme_msg(msg: CustomThemeConfig) -> None:
 def _populate_user_info_msg(msg: UserInfo) -> None:
     msg.installation_id = Installation.instance().installation_id
     msg.installation_id_v3 = Installation.instance().installation_id_v3
-
-
-def _populate_app_pages(msg: NewSession | PagesChanged, main_script_path: str) -> None:
-    for page_script_hash, page_info in source_util.get_pages(main_script_path).items():
-        page_proto = msg.app_pages.add()
-
-        page_proto.page_script_hash = page_script_hash
-        page_proto.page_name = page_info["page_name"]
-        page_proto.icon = page_info["icon"]

streamlit/runtime/fragment.py

@@ -133,6 +133,10 @@ def _fragment(
         )
         fragment_id = h.hexdigest()
 
+        # We intentionally want to capture the active script hash here to ensure
+        # that the fragment is associated with the correct script running.
+        initialized_active_script_hash = ctx.active_script_hash
+
         def wrapped_fragment():
             import streamlit as st
 
@@ -157,8 +161,20 @@ def _fragment(
                 ctx.current_fragment_id = fragment_id
 
             try:
-                with st.container():
-                    result = non_optional_func(*args, **kwargs)
+                # Make sure we set the active script hash to the same value
+                # for the fragment run as when defined upon initialization
+                # This ensures that elements (especially widgets) are tied
+                # to a consistent active script hash
+                active_hash_context = (
+                    ctx.pages_manager.run_with_active_hash(
+                        initialized_active_script_hash
+                    )
+                    if initialized_active_script_hash != ctx.active_script_hash
+                    else contextlib.nullcontext()
+                )
+                with active_hash_context:
+                    with st.container():
+                        result = non_optional_func(*args, **kwargs)
             finally:
                 ctx.current_fragment_id = None
 

streamlit/runtime/pages_manager.py

@@ -0,0 +1,354 @@
+# Copyright (c) Streamlit Inc. (2018-2022) Snowflake Inc. (2022-2024)
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import contextlib
+import os
+import threading
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, Final, Type
+
+from streamlit import source_util
+from streamlit.logger import get_logger
+from streamlit.runtime.scriptrunner.script_cache import ScriptCache
+from streamlit.util import calc_md5
+from streamlit.watcher import watch_dir
+
+if TYPE_CHECKING:
+    from streamlit.source_util import PageHash, PageInfo, PageName, ScriptPath
+
+_LOGGER: Final = get_logger(__name__)
+
+
+class PagesStrategyV1:
+    """
+    Strategy for MPA v1. This strategy handles pages being set directly
+    by a call to `st.navigation`. The key differences here are:
+    - The pages are defined by the existence of a `pages` directory
+    - We will ensure one watcher is watching the scripts in the directory.
+    - Only one script runs for a full rerun.
+    - We know at the beginning the intended page script to run.
+
+    NOTE: Thread safety of the pages is handled by the source_util module
+    """
+
+    is_watching_pages_dir: bool = False
+    pages_watcher_lock = threading.Lock()
+
+    # This is a static method because we only want to watch the pages directory
+    # once on initial load.
+    @staticmethod
+    def watch_pages_dir(pages_manager: PagesManager):
+        with PagesStrategyV1.pages_watcher_lock:
+            if PagesStrategyV1.is_watching_pages_dir:
+                return
+
+            def _handle_page_changed(_path: str) -> None:
+                source_util.invalidate_pages_cache()
+
+            main_script_path = Path(pages_manager.main_script_path)
+            pages_dir = main_script_path.parent / "pages"
+            watch_dir(
+                str(pages_dir),
+                _handle_page_changed,
+                glob_pattern="*.py",
+                allow_nonexistent=True,
+            )
+            PagesStrategyV1.is_watching_pages_dir = True
+
+    def __init__(self, pages_manager: PagesManager, setup_watcher: bool = True):
+        self.pages_manager = pages_manager
+
+        if setup_watcher:
+            PagesStrategyV1.watch_pages_dir(pages_manager)
+
+    # In MPA v1, there's no difference between the active hash
+    # and the page script hash.
+    def get_active_script_hash(self) -> "PageHash":
+        return self.pages_manager.current_page_hash
+
+    def set_active_script_hash(self, _page_hash: "PageHash"):
+        # Intentionally do nothing as MPA v1 active_script_hash does not
+        # differentiate the active_script_hash and the page_script_hash
+        pass
+
+    def get_initial_active_script(
+        self, page_script_hash: "PageHash", page_name: "PageName"
+    ) -> "PageInfo" | None:
+        pages = self.get_pages()
+
+        if page_script_hash:
+            return pages.get(page_script_hash, None)
+        elif not page_script_hash and page_name:
+            # If a user navigates directly to a non-main page of an app, we get
+            # the first script run request before the list of pages has been
+            # sent to the frontend. In this case, we choose the first script
+            # with a name matching the requested page name.
+            return next(
+                filter(
+                    # There seems to be this weird bug with mypy where it
+                    # thinks that p can be None (which is impossible given the
+                    # types of pages), so we add `p and` at the beginning of
+                    # the predicate to circumvent this.
+                    lambda p: p and (p["page_name"] == page_name),
+                    pages.values(),
+                ),
+                None,
+            )
+
+        # If no information about what page to run is given, default to
+        # running the main page.
+        # Safe because pages will at least contain the app's main page.
+        main_page_info = list(pages.values())[0]
+        return main_page_info
+
+    def get_pages(self) -> dict["PageHash", "PageInfo"]:
+        return source_util.get_pages(self.pages_manager.main_script_path)
+
+    def register_pages_changed_callback(
+        self,
+        callback: Callable[[str], None],
+    ) -> Callable[[], None]:
+        return source_util.register_pages_changed_callback(callback)
+
+    def set_pages(self, _pages: dict["PageHash", "PageInfo"]) -> None:
+        raise NotImplementedError("Unable to set pages in this V1 strategy")
+
+    def get_page_script(self, _fallback_page_hash: "PageHash") -> "PageInfo" | None:
+        raise NotImplementedError("Unable to get page script in this V1 strategy")
+
+
+class PagesStrategyV2:
+    """
+    Strategy for MPA v2. This strategy handles pages being set directly
+    by a call to `st.navigation`. The key differences here are:
+    - The pages are set directly by the user
+    - The initial active script will always be the main script
+    - More than one script can run in a single app run (sequentially),
+      so we must keep track of the active script hash
+    - We rely on pages manager to retrieve the intended page script per run
+
+    NOTE: We don't provide any locks on the pages since the pages are not
+    shared across sessions. Only the user script thread can write to
+    pages and the event loop thread only reads
+    """
+
+    def __init__(self, pages_manager: PagesManager, **kwargs):
+        self.pages_manager = pages_manager
+        self._active_script_hash: "PageHash" = self.pages_manager.main_script_hash
+        self._pages: dict["PageHash", "PageInfo"] | None = None
+
+    def get_active_script_hash(self) -> "PageHash":
+        return self._active_script_hash
+
+    def set_active_script_hash(self, page_hash: "PageHash"):
+        self._active_script_hash = page_hash
+
+    def get_initial_active_script(
+        self, page_script_hash: "PageHash", page_name: "PageName"
+    ) -> "PageInfo":
+        return {
+            # We always run the main script in V2 as it's the common code
+            "script_path": self.pages_manager.main_script_path,
+            "page_script_hash": page_script_hash
+            or self.pages_manager.main_script_hash,  # Default Hash
+        }
+
+    def get_page_script(self, fallback_page_hash: "PageHash") -> "PageInfo" | None:
+        if self._pages is None:
+            return None
+
+        if self.pages_manager.intended_page_script_hash:
+            # We assume that if initial page hash is specified, that a page should
+            # exist, so we check out the page script hash or the default page hash
+            # as a backup
+            return self._pages.get(
+                self.pages_manager.intended_page_script_hash,
+                self._pages.get(fallback_page_hash, None),
+            )
+        elif self.pages_manager.intended_page_name:
+            # If a user navigates directly to a non-main page of an app, the
+            # the page name can identify the page script to run
+            return next(
+                filter(
+                    # There seems to be this weird bug with mypy where it
+                    # thinks that p can be None (which is impossible given the
+                    # types of pages), so we add `p and` at the beginning of
+                    # the predicate to circumvent this.
+                    lambda p: p
+                    and (p["url_pathname"] == self.pages_manager.intended_page_name),
+                    self._pages.values(),
+                ),
+                None,
+            )
+
+        return self._pages.get(fallback_page_hash, None)
+
+    def get_pages(self) -> dict["PageHash", "PageInfo"]:
+        # If pages are not set, provide the common page info where
+        # - the main script path is the executing script to start
+        # - the page script hash and name reflects the intended page requested
+        return self._pages or {
+            self.pages_manager.main_script_hash: {
+                "page_script_hash": self.pages_manager.intended_page_script_hash or "",
+                "page_name": self.pages_manager.intended_page_name or "",
+                "icon": "",
+                "script_path": self.pages_manager.main_script_path,
+            }
+        }
+
+    def set_pages(self, pages: dict["PageHash", "PageInfo"]) -> None:
+        self._pages = pages
+
+    def register_pages_changed_callback(
+        self,
+        callback: Callable[[str], None],
+    ) -> Callable[[], None]:
+        # V2 strategy does not handle any pages changed event
+        return lambda: None
+
+
+class PagesManager:
+    """
+    PagesManager is responsible for managing the set of pages based on the
+    strategy. By default, PagesManager uses V1 which relies on the original
+    assumption that there exists a `pages` directory with all the scripts.
+
+    If the `pages` are being set directly, the strategy is switched to V2.
+    This indicates someone has written an `st.navigation` call in their app
+    which informs us of the pages.
+
+    NOTE: Each strategy handles its own thread safety when accessing the pages
+    """
+
+    DefaultStrategy: Type[PagesStrategyV1 | PagesStrategyV2] = PagesStrategyV1
+
+    def __init__(
+        self,
+        main_script_path: "ScriptPath",
+        script_cache: ScriptCache | None = None,
+        **kwargs,
+    ):
+        self._main_script_path = main_script_path
+        self._main_script_hash: "PageHash" = calc_md5(main_script_path)
+        self._current_page_hash: "PageHash" = self._main_script_hash
+        self.pages_strategy = PagesManager.DefaultStrategy(self, **kwargs)
+        self._script_cache = script_cache
+        self._intended_page_script_hash: "PageHash" | None = None
+        self._intended_page_name: "PageName" | None = None
+
+    @property
+    def current_page_hash(self) -> "PageHash":
+        return self._current_page_hash
+
+    @property
+    def main_script_path(self) -> "ScriptPath":
+        return self._main_script_path
+
+    @property
+    def main_script_hash(self) -> "PageHash":
+        return self._main_script_hash
+
+    @property
+    def intended_page_name(self) -> "PageName" | None:
+        return self._intended_page_name
+
+    @property
+    def intended_page_script_hash(self) -> "PageHash" | None:
+        return self._intended_page_script_hash
+
+    def get_main_page(self) -> "PageInfo":
+        return {
+            "script_path": self._main_script_path,
+            "page_script_hash": self._main_script_hash,
+        }
+
+    def get_current_page_script_hash(self) -> "PageHash":
+        """Gets the script hash of the associated page of a script."""
+        return self._current_page_hash
+
+    def set_current_page_script_hash(self, page_hash: "PageHash") -> None:
+        self._current_page_hash = page_hash
+
+    def get_active_script_hash(self) -> "PageHash":
+        """Gets the script hash of the currently executing script."""
+        return self.pages_strategy.get_active_script_hash()
+
+    def set_active_script_hash(self, page_hash: "PageHash"):
+        return self.pages_strategy.set_active_script_hash(page_hash)
+
+    def set_script_intent(
+        self, page_script_hash: "PageHash", page_name: "PageName"
+    ) -> None:
+        self._intended_page_script_hash = page_script_hash
+        self._intended_page_name = page_name
+
+    def get_initial_active_script(
+        self, page_script_hash: "PageHash", page_name: "PageName"
+    ) -> "PageInfo" | None:
+        return self.pages_strategy.get_initial_active_script(
+            page_script_hash, page_name
+        )
+
+    @contextlib.contextmanager
+    def run_with_active_hash(self, page_hash: "PageHash"):
+        original_page_hash = self.get_active_script_hash()
+        self.set_active_script_hash(page_hash)
+        try:
+            yield
+        finally:
+            # in the event of any exception, ensure we set the active hash back
+            self.set_active_script_hash(original_page_hash)
+
+    def get_pages(self) -> dict["PageHash", "PageInfo"]:
+        return self.pages_strategy.get_pages()
+
+    def set_pages(self, pages: dict["PageHash", "PageInfo"]) -> None:
+        # Manually setting the pages indicates we are using MPA v2.
+        if isinstance(self.pages_strategy, PagesStrategyV1):
+            if os.path.exists(Path(self.main_script_path).parent / "pages"):
+                _LOGGER.warning(
+                    "st.navigation was called in an app with a pages/ directory. This may cause unusual app behavior. You may want to rename the pages/ directory."
+                )
+            PagesManager.DefaultStrategy = PagesStrategyV2
+            self.pages_strategy = PagesStrategyV2(self)
+
+        self.pages_strategy.set_pages(pages)
+
+    def get_page_script(self, fallback_page_hash: "PageHash" = "") -> "PageInfo" | None:
+        # We assume the pages strategy is V2 cause this is used
+        # in the st.navigation call, but we just swallow the error
+        try:
+            return self.pages_strategy.get_page_script(fallback_page_hash)
+        except NotImplementedError:
+            return None
+
+    def register_pages_changed_callback(
+        self,
+        callback: Callable[[str], None],
+    ) -> Callable[[], None]:
+        """Register a callback to be called when the set of pages changes.
+
+        The callback will be called with the path changed.
+        """
+
+        return self.pages_strategy.register_pages_changed_callback(callback)
+
+    def get_page_script_byte_code(self, script_path: str) -> Any:
+        if self._script_cache is None:
+            # Returning an empty string for an empty script
+            return ""
+
+        return self._script_cache.get_bytecode(script_path)

streamlit/runtime/scriptrunner/script_run_context.py

@@ -33,6 +33,7 @@ from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 
 if TYPE_CHECKING:
     from streamlit.runtime.fragment import FragmentStorage
+    from streamlit.runtime.pages_manager import PagesManager
 
 _LOGGER: Final = get_logger(__name__)
 
@@ -60,9 +61,9 @@ class ScriptRunContext:
     session_state: SafeSessionState
     uploaded_file_mgr: UploadedFileManager
     main_script_path: str
-    page_script_hash: str
     user_info: UserInfo
     fragment_storage: "FragmentStorage"
+    pages_manager: "PagesManager"
 
     gather_usage_stats: bool = False
     command_tracking_deactivated: bool = False
@@ -87,6 +88,14 @@ class ScriptRunContext:
     _experimental_query_params_used = False
     _production_query_params_used = False
 
+    @property
+    def page_script_hash(self):
+        return self.pages_manager.get_current_page_script_hash()
+
+    @property
+    def active_script_hash(self):
+        return self.pages_manager.get_active_script_hash()
+
     def reset(
         self,
         query_string: str = "",
@@ -98,7 +107,7 @@ class ScriptRunContext:
         self.widget_user_keys_this_run = set()
         self.form_ids_this_run = set()
         self.query_string = query_string
-        self.page_script_hash = page_script_hash
+        self.pages_manager.set_current_page_script_hash(page_script_hash)
         # Permit set_page_config when the ScriptRunContext is reused on a rerun
         self._set_page_config_allowed = True
         self._has_script_started = False
@@ -142,6 +151,8 @@ class ScriptRunContext:
         ):
             self._set_page_config_allowed = False
 
+        msg.metadata.active_script_hash = self.active_script_hash
+
         # Pass the message up to our associated ScriptRunner.
         self._enqueue(msg)