streamlit-nightly 1.42.3.dev20250226__py2.py3-none-any.whl → 1.42.3.dev20250227__py2.py3-none-any.whl

streamlit/runtime/pages_manager.py

@@ -14,15 +14,11 @@
 
 from __future__ import annotations
 
-import os
-import threading
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Callable, Final
+from typing import TYPE_CHECKING, Any, Final
 
-from streamlit import source_util
 from streamlit.logger import get_logger
 from streamlit.util import calc_md5
-from streamlit.watcher import watch_dir
 
 if TYPE_CHECKING:
     from streamlit.runtime.scriptrunner.script_cache import ScriptCache
@@ -31,198 +27,15 @@ if TYPE_CHECKING:
 _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()
-
-            pages_dir = pages_manager.main_script_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)
-
-    @property
-    def initial_active_script_hash(self) -> PageHash:
-        return self.pages_manager.current_page_script_hash
-
-    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._pages: dict[PageHash, PageInfo] | None = None
-
-    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
-        }
-
-    @property
-    def initial_active_script_hash(self) -> PageHash:
-        return self.pages_manager.main_script_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
+    PagesManager is responsible for managing the set of pages that make up
+    the entire application. At the start we assume the main script is the
+    only page. As the script runs, the main script can call `st.navigation`
+    to set the set of pages that make up the app.
     """
 
-    DefaultStrategy: type[PagesStrategyV1 | PagesStrategyV2] = PagesStrategyV1
+    uses_pages_directory: bool | None = None
 
     def __init__(
         self,
@@ -232,11 +45,23 @@ class PagesManager:
     ):
         self._main_script_path = main_script_path
         self._main_script_hash: PageHash = calc_md5(main_script_path)
-        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
         self._current_page_script_hash: PageHash = ""
+        self._pages: dict[PageHash, PageInfo] | None = None
+        # A relic of v1 of Multipage apps, we performed special handling
+        # for apps with a pages directory. We will keep this flag around
+        # for now to maintain the behavior for apps that were created with
+        # the pages directory feature.
+        #
+        # NOTE: we will update the feature if the flag has not been set
+        #       this means that if users use v2 behavior, the flag will
+        #       always be set to False
+        if PagesManager.uses_pages_directory is None:
+            PagesManager.uses_pages_directory = Path(
+                self.main_script_parent / "pages"
+            ).exists()
 
     @property
     def main_script_path(self) -> ScriptPath:
@@ -262,14 +87,6 @@ class PagesManager:
     def intended_page_script_hash(self) -> PageHash | None:
         return self._intended_page_script_hash
 
-    @property
-    def initial_active_script_hash(self) -> PageHash:
-        return self.pages_strategy.initial_active_script_hash
-
-    @property
-    def mpa_version(self) -> int:
-        return 2 if isinstance(self.pages_strategy, PagesStrategyV2) else 1
-
     def set_current_page_script_hash(self, page_script_hash: PageHash) -> None:
         self._current_page_script_hash = page_script_hash
 
@@ -288,45 +105,57 @@ class PagesManager:
     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
-        )
+        return {
+            # We always run the main script in V2 as it's the common code
+            "script_path": self.main_script_path,
+            "page_script_hash": page_script_hash
+            or self.main_script_hash,  # Default Hash
+        }
 
     def get_pages(self) -> dict[PageHash, PageInfo]:
-        return self.pages_strategy.get_pages()
+        # 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.main_script_hash: {
+                "page_script_hash": self.intended_page_script_hash or "",
+                "page_name": self.intended_page_name or "",
+                "icon": "",
+                "script_path": self.main_script_path,
+            }
+        }
 
     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(self.main_script_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)
+        self._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:
+        if self._pages is None:
             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.
-        """
+        if self.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.intended_page_script_hash,
+                self._pages.get(fallback_page_hash, None),
+            )
+        elif self.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.intended_page_name),
+                    self._pages.values(),
+                ),
+                None,
+            )
 
-        return self.pages_strategy.register_pages_changed_callback(callback)
+        return self._pages.get(fallback_page_hash, None)
 
     def get_page_script_byte_code(self, script_path: str) -> Any:
         if self._script_cache is None:

streamlit/runtime/scriptrunner/script_runner.py

@@ -21,7 +21,7 @@ import types
 from contextlib import contextmanager
 from enum import Enum
 from timeit import default_timer as timer
-from typing import TYPE_CHECKING, Callable, Final
+from typing import TYPE_CHECKING, Callable, Final, Literal, cast
 
 from blinker import Signal
 
@@ -34,6 +34,7 @@ from streamlit.runtime.metrics_util import (
     create_page_profile_message,
     to_microseconds,
 )
+from streamlit.runtime.pages_manager import PagesManager
 from streamlit.runtime.scriptrunner.exec_code import (
     exec_func_with_error_handling,
     modified_sys_path,
@@ -58,10 +59,10 @@ from streamlit.runtime.state import (
     SafeSessionState,
     SessionState,
 )
+from streamlit.source_util import page_sort_key
 
 if TYPE_CHECKING:
     from streamlit.runtime.fragment import FragmentStorage
-    from streamlit.runtime.pages_manager import PagesManager
     from streamlit.runtime.scriptrunner.script_cache import ScriptCache
     from streamlit.runtime.uploaded_file_manager import UploadedFileManager
 
@@ -116,6 +117,50 @@ it in the future.
 """
 
 
+# For projects that have a pages folder, we assume that this is a script that
+# is designed to leverage our original v1 version of multi-page apps. This
+# function will be called to run the script in lieu of the main script. This
+# function simulates the v1 setup using the modern v2 commands (st.navigation)
+def _mpa_v1(main_script_path: str):
+    from pathlib import Path
+
+    from streamlit.commands.navigation import PageType, _navigation
+    from streamlit.navigation.page import StreamlitPage
+
+    # Select the folder that should be used for the pages:
+    MAIN_SCRIPT_PATH = Path(main_script_path).resolve()
+    PAGES_FOLDER = MAIN_SCRIPT_PATH.parent / "pages"
+
+    # Read out the my_pages folder and create a page for every script:
+    pages = PAGES_FOLDER.glob("*.py")
+    pages = sorted(
+        [page for page in pages if page.name.endswith(".py")], key=page_sort_key
+    )
+
+    # Use this script as the main page and
+    main_page = StreamlitPage(MAIN_SCRIPT_PATH, default=True)
+    all_pages = [main_page] + [
+        StreamlitPage(PAGES_FOLDER / page.name) for page in pages
+    ]
+    # Initialize the navigation with all the pages:
+    position: Literal["sidebar", "hidden"] = (
+        "hidden"
+        if config.get_option("client.showSidebarNavigation") is False
+        else "sidebar"
+    )
+    page = _navigation(
+        cast(list[PageType], all_pages),
+        position=position,
+        expanded=False,
+    )
+
+    if page._page != main_page._page:
+        # Only run the page if it is not pointing to this script:
+        page.run()
+        # Finish the script execution here to only run the selected page
+        raise StopException()
+
+
 class ScriptRunner:
     def __init__(
         self,
@@ -590,6 +635,8 @@ class ScriptRunner:
                                 pass
 
                     else:
+                        if PagesManager.uses_pages_directory:
+                            _mpa_v1(self._main_script_path)
                         exec(code, module.__dict__)
                         self._fragment_storage.clear(
                             new_fragment_ids=ctx.new_fragment_ids

streamlit/runtime/scriptrunner_utils/script_run_context.py

@@ -149,7 +149,7 @@ class ScriptRunContext:
         self.query_string = query_string
         self.context_info = context_info
         self.pages_manager.set_current_page_script_hash(page_script_hash)
-        self._active_script_hash = self.pages_manager.initial_active_script_hash
+        self._active_script_hash = self.pages_manager.main_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

streamlit/source_util.py

@@ -15,16 +15,15 @@
 from __future__ import annotations
 
 import re
-import threading
-from pathlib import Path
-from typing import Callable, Final, TypedDict
+from typing import TYPE_CHECKING, Final, TypedDict
 
-from blinker import Signal
 from typing_extensions import NotRequired, TypeAlias
 
 from streamlit.logger import get_logger
 from streamlit.string_util import extract_leading_emoji
-from streamlit.util import calc_md5
+
+if TYPE_CHECKING:
+    from pathlib import Path
 
 _LOGGER: Final = get_logger(__name__)
 
@@ -97,88 +96,3 @@ def page_icon_and_name(script_path: Path) -> tuple[str, str]:
     ).strip() or extraction.group(1)
 
     return extract_leading_emoji(icon_and_name)
-
-
-_pages_cache_lock = threading.RLock()
-_cached_pages: dict[PageHash, PageInfo] | None = None
-_on_pages_changed = Signal(doc="Emitted when the pages directory is changed")
-
-
-def invalidate_pages_cache() -> None:
-    global _cached_pages
-
-    _LOGGER.debug("Pages directory changed")
-    with _pages_cache_lock:
-        _cached_pages = None
-
-    _on_pages_changed.send()
-
-
-def get_pages(main_script_path_str: ScriptPath) -> dict[PageHash, PageInfo]:
-    global _cached_pages
-
-    # Avoid taking the lock if the pages cache hasn't been invalidated.
-    precached_pages = _cached_pages
-    if precached_pages is not None:
-        return precached_pages
-
-    with _pages_cache_lock:
-        # The cache may have been repopulated while we were waiting to grab
-        # the lock.
-        if _cached_pages is not None:
-            return _cached_pages
-
-        main_script_path = Path(main_script_path_str)
-        main_page_icon, main_page_name = page_icon_and_name(main_script_path)
-        main_script_hash = calc_md5(main_script_path_str)
-
-        # NOTE: We include the script_hash in the dict even though it is
-        #       already used as the key because that occasionally makes things
-        #       easier for us when we need to iterate over pages.
-        pages: dict[PageHash, PageInfo] = {
-            main_script_hash: {
-                "page_script_hash": main_script_hash,
-                "page_name": main_page_name,
-                "icon": main_page_icon,
-                "script_path": str(main_script_path.resolve()),
-            }
-        }
-
-        pages_dir = main_script_path.parent / "pages"
-        page_scripts = sorted(
-            [
-                f
-                for f in pages_dir.glob("*.py")
-                if not f.name.startswith(".") and not f.name == "__init__.py"
-            ],
-            key=page_sort_key,
-        )
-
-        for script_path in page_scripts:
-            script_path_str = str(script_path.resolve())
-            pi, pn = page_icon_and_name(script_path)
-            psh = calc_md5(script_path_str)
-
-            pages[psh] = {
-                "page_script_hash": psh,
-                "page_name": pn,
-                "icon": pi,
-                "script_path": script_path_str,
-            }
-
-        _cached_pages = pages
-
-        return pages
-
-
-def register_pages_changed_callback(
-    callback: Callable[[str], None],
-) -> Callable[[], None]:
-    def disconnect():
-        _on_pages_changed.disconnect(callback)
-
-    # weak=False so that we have control of when the pages changed
-    # callback is deregistered.
-    _on_pages_changed.connect(callback, weak=False)
-
-    return disconnect

streamlit/static/index.html

@@ -51,7 +51,7 @@
     <script>
       window.prerenderReady = false
     </script>
-    <script type="module" crossorigin src="./static/js/index.KPwXWqBk.js"></script>
+    <script type="module" crossorigin src="./static/js/index.DfNAkKAr.js"></script>
     <link rel="stylesheet" crossorigin href="./static/css/index.DpJG_94W.css">
   </head>
   <body>

streamlit/static/static/js/{FileDownload.esm.CWn5B5ZN.js → FileDownload.esm.rdZtCw5-.js}

@@ -1 +1 @@
-import{r as e,E as n,_ as a}from"./index.KPwXWqBk.js";var o=e.forwardRef(function(t,r){var l={fill:"currentColor",xmlns:"http://www.w3.org/2000/svg"};return e.createElement(n,a({iconAttrs:l,iconVerticalAlign:"middle",iconViewBox:"0 0 24 24"},t,{ref:r}),e.createElement("path",{fill:"none",d:"M0 0h24v24H0V0z"}),e.createElement("path",{d:"M16 9v10H8V9h8m-1.5-6h-5l-1 1H5v2h14V4h-3.5l-1-1zM18 7H6v12c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7z"}))});o.displayName="Delete";var i=e.forwardRef(function(t,r){var l={fill:"currentColor",xmlns:"http://www.w3.org/2000/svg"};return e.createElement(n,a({iconAttrs:l,iconVerticalAlign:"middle",iconViewBox:"0 0 24 24"},t,{ref:r}),e.createElement("rect",{width:24,height:24,fill:"none"}),e.createElement("path",{d:"M18 15v3H6v-3H4v3c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2v-3h-2zm-1-4l-1.41-1.41L13 12.17V4h-2v8.17L8.41 9.59 7 11l5 5 5-5z"}))});i.displayName="FileDownload";export{o as D,i as F};
+import{r as e,E as n,_ as a}from"./index.DfNAkKAr.js";var o=e.forwardRef(function(t,r){var l={fill:"currentColor",xmlns:"http://www.w3.org/2000/svg"};return e.createElement(n,a({iconAttrs:l,iconVerticalAlign:"middle",iconViewBox:"0 0 24 24"},t,{ref:r}),e.createElement("path",{fill:"none",d:"M0 0h24v24H0V0z"}),e.createElement("path",{d:"M16 9v10H8V9h8m-1.5-6h-5l-1 1H5v2h14V4h-3.5l-1-1zM18 7H6v12c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V7z"}))});o.displayName="Delete";var i=e.forwardRef(function(t,r){var l={fill:"currentColor",xmlns:"http://www.w3.org/2000/svg"};return e.createElement(n,a({iconAttrs:l,iconVerticalAlign:"middle",iconViewBox:"0 0 24 24"},t,{ref:r}),e.createElement("rect",{width:24,height:24,fill:"none"}),e.createElement("path",{d:"M18 15v3H6v-3H4v3c0 1.1.9 2 2 2h12c1.1 0 2-.9 2-2v-3h-2zm-1-4l-1.41-1.41L13 12.17V4h-2v8.17L8.41 9.59 7 11l5 5 5-5z"}))});i.displayName="FileDownload";export{o as D,i as F};