streamlit-nightly 1.31.2.dev20240212__py2.py3-none-any.whl → 1.31.2.dev20240214__py2.py3-none-any.whl

streamlit/watcher/event_based_path_watcher.py

@@ -39,7 +39,7 @@ from __future__ import annotations
 
 import os
 import threading
-from typing import Callable, Dict, Final, cast
+from typing import Callable, Final, cast
 
 from blinker import ANY, Signal
 from watchdog import events
@@ -109,13 +109,13 @@ class EventBasedPathWatcher:
         path_watcher.stop_watching_path(self._path, self._on_changed)
 
 
-class _MultiPathWatcher(object):
+class _MultiPathWatcher:
     """Watches multiple paths."""
 
-    _singleton: "_MultiPathWatcher" | None = None
+    _singleton: _MultiPathWatcher | None = None
 
     @classmethod
-    def get_singleton(cls) -> "_MultiPathWatcher":
+    def get_singleton(cls) -> _MultiPathWatcher:
         """Return the singleton _MultiPathWatcher object.
 
         Instantiates one if necessary.
@@ -127,18 +127,18 @@ class _MultiPathWatcher(object):
         return cast("_MultiPathWatcher", _MultiPathWatcher._singleton)
 
     # Don't allow constructor to be called more than once.
-    def __new__(cls) -> "_MultiPathWatcher":
+    def __new__(cls) -> _MultiPathWatcher:
         """Constructor."""
         if _MultiPathWatcher._singleton is not None:
             raise RuntimeError("Use .get_singleton() instead")
-        return super(_MultiPathWatcher, cls).__new__(cls)
+        return super().__new__(cls)
 
     def __init__(self) -> None:
         """Constructor."""
         _MultiPathWatcher._singleton = self
 
         # Map of folder_to_watch -> _FolderEventHandler.
-        self._folder_handlers: Dict[str, _FolderEventHandler] = {}
+        self._folder_handlers: dict[str, _FolderEventHandler] = {}
 
         # Used for mutation of _folder_handlers dict
         self._lock = threading.Lock()
@@ -218,7 +218,7 @@ class _MultiPathWatcher(object):
             self._observer.join(timeout=5)
 
 
-class WatchedPath(object):
+class WatchedPath:
     """Emits notifications when a single path is modified."""
 
     def __init__(
@@ -254,8 +254,8 @@ class _FolderEventHandler(events.FileSystemEventHandler):
     """
 
     def __init__(self) -> None:
-        super(_FolderEventHandler, self).__init__()
-        self._watched_paths: Dict[str, WatchedPath] = {}
+        super().__init__()
+        self._watched_paths: dict[str, WatchedPath] = {}
         self._lock = threading.Lock()  # for watched_paths mutations
         self.watch: ObservedWatch | None = None
 

streamlit/watcher/local_sources_watcher.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import collections
 import os
 import sys
 import types
-from typing import Callable, Dict, List, Optional, Set
+from typing import Callable, Final
 
 from streamlit import config, file_util
 from streamlit.folder_black_list import FolderBlackList
@@ -27,7 +29,7 @@ from streamlit.watcher.path_watcher import (
     get_default_path_watcher_class,
 )
 
-LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 WatchedModule = collections.namedtuple("WatchedModule", ["watcher", "module_name"])
 
@@ -40,23 +42,23 @@ class LocalSourcesWatcher:
     def __init__(self, main_script_path: str):
         self._main_script_path = os.path.abspath(main_script_path)
         self._script_folder = os.path.dirname(self._main_script_path)
-        self._on_file_changed: List[Callable[[str], None]] = []
+        self._on_file_changed: list[Callable[[str], None]] = []
         self._is_closed = False
-        self._cached_sys_modules: Set[str] = set()
+        self._cached_sys_modules: set[str] = set()
 
         # Blacklist for folders that should not be watched
         self._folder_black_list = FolderBlackList(
             config.get_option("server.folderWatchBlacklist")
         )
 
-        self._watched_modules: Dict[str, WatchedModule] = {}
-        self._watched_pages: Set[str] = set()
+        self._watched_modules: dict[str, WatchedModule] = {}
+        self._watched_pages: set[str] = set()
 
         self.update_watched_pages()
 
     def update_watched_pages(self) -> None:
         old_watched_pages = self._watched_pages
-        new_pages_paths: Set[str] = set()
+        new_pages_paths: set[str] = set()
 
         for page_info in get_pages(self._main_script_path).values():
             new_pages_paths.add(page_info["script_path"])
@@ -77,7 +79,7 @@ class LocalSourcesWatcher:
 
     def on_file_changed(self, filepath):
         if filepath not in self._watched_modules:
-            LOGGER.error("Received event for non-watched file: %s", filepath)
+            _LOGGER.error("Received event for non-watched file: %s", filepath)
             return
 
         # Workaround:
@@ -159,17 +161,17 @@ class LocalSourcesWatcher:
             self._cached_sys_modules = set(sys.modules)
             self._register_necessary_watchers(modules_paths)
 
-    def _register_necessary_watchers(self, module_paths: Dict[str, Set[str]]) -> None:
+    def _register_necessary_watchers(self, module_paths: dict[str, set[str]]) -> None:
         for name, paths in module_paths.items():
             for path in paths:
                 if self._file_should_be_watched(path):
                     self._register_watcher(path, name)
 
-    def _exclude_blacklisted_paths(self, paths: Set[str]) -> Set[str]:
+    def _exclude_blacklisted_paths(self, paths: set[str]) -> set[str]:
         return {p for p in paths if not self._folder_black_list.is_blacklisted(p)}
 
 
-def get_module_paths(module: types.ModuleType) -> Set[str]:
+def get_module_paths(module: types.ModuleType) -> set[str]:
     paths_extractors = [
         # https://docs.python.org/3/reference/datamodel.html
         # __file__ is the pathname of the file from which the module was loaded
@@ -202,7 +204,7 @@ def get_module_paths(module: types.ModuleType) -> Set[str]:
             # Some modules might not have __file__ or __spec__ attributes.
             pass
         except Exception as e:
-            LOGGER.warning(f"Examining the path of {module.__name__} raised: {e}")
+            _LOGGER.warning(f"Examining the path of {module.__name__} raised: {e}")
 
         all_paths.update(
             [os.path.abspath(str(p)) for p in potential_paths if _is_valid_path(p)]
@@ -210,5 +212,5 @@ def get_module_paths(module: types.ModuleType) -> Set[str]:
     return all_paths
 
 
-def _is_valid_path(path: Optional[str]) -> bool:
+def _is_valid_path(path: str | None) -> bool:
     return isinstance(path, str) and (os.path.isfile(path) or os.path.isdir(path))

streamlit/watcher/path_watcher.py

@@ -18,11 +18,8 @@ from typing import Callable, Type, Union
 
 import streamlit.watcher
 from streamlit import cli_util, config, env_util
-from streamlit.logger import get_logger
 from streamlit.watcher.polling_path_watcher import PollingPathWatcher
 
-LOGGER = get_logger(__name__)
-
 
 # local_sources_watcher.py caches the return value of
 # get_default_path_watcher_class(), so it needs to differentiate between the

streamlit/watcher/polling_path_watcher.py

@@ -14,19 +14,20 @@
 
 """A class that watches a given path via polling."""
 
+from __future__ import annotations
+
 import time
 from concurrent.futures import ThreadPoolExecutor
-from typing import Callable, Optional
+from typing import Callable, Final
 
 from streamlit.logger import get_logger
 from streamlit.util import repr_
 from streamlit.watcher import util
 
-LOGGER = get_logger(__name__)
-
+_LOGGER: Final = get_logger(__name__)
 
-_MAX_WORKERS = 4
-_POLLING_PERIOD_SECS = 0.2
+_MAX_WORKERS: Final = 4
+_POLLING_PERIOD_SECS: Final = 0.2
 
 
 class PollingPathWatcher:
@@ -41,14 +42,14 @@ class PollingPathWatcher:
         This is a no-op, and exists for interface parity with
         EventBasedPathWatcher.
         """
-        LOGGER.debug("Watcher closed")
+        _LOGGER.debug("Watcher closed")
 
     def __init__(
         self,
         path: str,
         on_changed: Callable[[str], None],
         *,  # keyword-only arguments:
-        glob_pattern: Optional[str] = None,
+        glob_pattern: str | None = None,
         allow_nonexistent: bool = False,
     ) -> None:
         """Constructor.
@@ -113,7 +114,7 @@ class PollingPathWatcher:
 
         self._md5 = md5
 
-        LOGGER.debug("Change detected: %s", self._path)
+        _LOGGER.debug("Change detected: %s", self._path)
         self._on_changed(self._path)
 
         self._schedule()

streamlit/watcher/util.py

@@ -18,11 +18,12 @@ These are functions that only make sense within the watcher. In particular,
 functions that use streamlit.config can go here to avoid a dependency cycle.
 """
 
+from __future__ import annotations
+
 import hashlib
 import os
 import time
 from pathlib import Path
-from typing import Optional
 
 from streamlit.util import HASHLIB_KWARGS
 
@@ -36,7 +37,7 @@ _RETRY_WAIT_SECS = 0.1
 def calc_md5_with_blocking_retries(
     path: str,
     *,  # keyword-only arguments:
-    glob_pattern: Optional[str] = None,
+    glob_pattern: str | None = None,
     allow_nonexistent: bool = False,
 ) -> str:
     """Calculate the MD5 checksum of a given path.

streamlit/web/cache_storage_manager_config.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from streamlit.runtime.caching.storage import CacheStorageManager
 from streamlit.runtime.caching.storage.local_disk_cache_storage import (
     LocalDiskCacheStorageManager,

streamlit/web/server/app_static_file_handler.py

@@ -12,17 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import mimetypes
 import os
 from pathlib import Path
-from typing import Optional
+from typing import Final
 
 import tornado.web
 
 from streamlit.logger import get_logger
 
-_LOGGER = get_logger(__name__)
-
+_LOGGER: Final = get_logger(__name__)
 
 # We agreed on these limitations for the initial release of static file sharing,
 # based on security concerns from the SiS and Community Cloud teams
@@ -34,11 +35,11 @@ SAFE_APP_STATIC_FILE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".gif", ".webp")
 
 
 class AppStaticFileHandler(tornado.web.StaticFileHandler):
-    def initialize(self, path: str, default_filename: Optional[str] = None) -> None:
+    def initialize(self, path: str, default_filename: str | None = None) -> None:
         super().initialize(path, default_filename)
         mimetypes.add_type("image/webp", ".webp")
 
-    def validate_absolute_path(self, root: str, absolute_path: str) -> Optional[str]:
+    def validate_absolute_path(self, root: str, absolute_path: str) -> str | None:
         full_path = os.path.realpath(absolute_path)
 
         if os.path.isdir(full_path):

streamlit/web/server/browser_websocket_handler.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import base64
 import binascii
 import json
-from typing import Any, Awaitable, Dict, List, Optional, Union
+from typing import Any, Awaitable, Final
 
 import tornado.concurrent
 import tornado.locks
@@ -23,7 +25,6 @@ import tornado.netutil
 import tornado.web
 import tornado.websocket
 from tornado.websocket import WebSocketHandler
-from typing_extensions import Final
 
 from streamlit import config
 from streamlit.logger import get_logger
@@ -41,7 +42,7 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
 
     def initialize(self, runtime: Runtime) -> None:
         self._runtime = runtime
-        self._session_id: Optional[str] = None
+        self._session_id: str | None = None
         # The XSRF cookie is normally set when xsrf_form_html is used, but in a
         # pure-Javascript application that does not use any regular forms we just
         # need to read the self.xsrf_token manually to set the cookie as a side
@@ -61,7 +62,7 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
         except tornado.websocket.WebSocketClosedError as e:
             raise SessionClientDisconnectedError from e
 
-    def select_subprotocol(self, subprotocols: List[str]) -> Optional[str]:
+    def select_subprotocol(self, subprotocols: list[str]) -> str | None:
         """Return the first subprotocol in the given list.
 
         This method is used by Tornado to select a protocol when the
@@ -87,7 +88,7 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
 
         return None
 
-    def open(self, *args, **kwargs) -> Optional[Awaitable[None]]:
+    def open(self, *args, **kwargs) -> Awaitable[None] | None:
         # Extract user info from the X-Streamlit-User header
         is_public_cloud_app = False
 
@@ -100,7 +101,8 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
         except (KeyError, binascii.Error, json.decoder.JSONDecodeError):
             email = "test@example.com"
 
-        user_info: Dict[str, Optional[str]] = dict()
+        user_info: dict[str, str | None] = dict()
+
         if is_public_cloud_app:
             user_info["email"] = None
         else:
@@ -135,7 +137,7 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
         self._runtime.disconnect_session(self._session_id)
         self._session_id = None
 
-    def get_compression_options(self) -> Optional[Dict[Any, Any]]:
+    def get_compression_options(self) -> dict[Any, Any] | None:
         """Enable WebSocket compression.
 
         Returning an empty dict enables websocket compression. Returning
@@ -147,7 +149,7 @@ class BrowserWebSocketHandler(WebSocketHandler, SessionClient):
             return {}
         return None
 
-    def on_message(self, payload: Union[str, bytes]) -> None:
+    def on_message(self, payload: str | bytes) -> None:
         if not self._session_id:
             return
 

streamlit/web/server/component_request_handler.py

@@ -12,8 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import mimetypes
 import os
+from typing import Final
 
 import tornado.web
 
@@ -21,7 +24,7 @@ import streamlit.web.server.routes
 from streamlit.components.v1.components import ComponentRegistry
 from streamlit.logger import get_logger
 
-_LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 
 class ComponentRequestHandler(tornado.web.RequestHandler):
@@ -63,7 +66,7 @@ class ComponentRequestHandler(tornado.web.RequestHandler):
 
         self.set_extra_headers(path)
 
-    def set_extra_headers(self, path) -> None:
+    def set_extra_headers(self, path: str) -> None:
         """Disable cache for HTML files.
 
         Other assets like JS and CSS are suffixed with their hash, so they can
@@ -86,7 +89,7 @@ class ComponentRequestHandler(tornado.web.RequestHandler):
         self.finish()
 
     @staticmethod
-    def get_content_type(abspath) -> str:
+    def get_content_type(abspath: str) -> str:
         """Returns the ``Content-Type`` header to be used for this request.
         From tornado.web.StaticFileHandler.
         """
@@ -108,4 +111,4 @@ class ComponentRequestHandler(tornado.web.RequestHandler):
     @staticmethod
     def get_url(file_id: str) -> str:
         """Return the URL for a component file with the given ID."""
-        return "components/{}".format(file_id)
+        return f"components/{file_id}"

streamlit/web/server/media_file_handler.py

@@ -12,7 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional
+from __future__ import annotations
+
 from urllib.parse import quote
 
 import tornado.web
@@ -67,11 +68,11 @@ class MediaFileHandler(tornado.web.StaticFileHandler):
                 # Check that the value can be encoded in latin1. Latin1 is
                 # the default encoding for headers.
                 filename.encode("latin1")
-                file_expr = 'filename="{}"'.format(filename)
+                file_expr = f'filename="{filename}"'
             except UnicodeEncodeError:
                 # RFC5987 syntax.
                 # See: https://datatracker.ietf.org/doc/html/rfc5987
-                file_expr = "filename*=utf-8''{}".format(quote(filename))
+                file_expr = f"filename*=utf-8''{quote(filename)}"
 
             self.set_header("Content-Disposition", f"attachment; {file_expr}")
 
@@ -112,7 +113,7 @@ class MediaFileHandler(tornado.web.StaticFileHandler):
 
     @classmethod
     def get_content(
-        cls, abspath: str, start: Optional[int] = None, end: Optional[int] = None
+        cls, abspath: str, start: int | None = None, end: int | None = None
     ):
         _LOGGER.debug("MediaFileHandler: GET %s", abspath)
 

streamlit/web/server/routes.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import os
+from typing import Final
 
 import tornado.web
 
@@ -21,10 +24,10 @@ from streamlit.logger import get_logger
 from streamlit.runtime.runtime_util import serialize_forward_msg
 from streamlit.web.server.server_util import emit_endpoint_deprecation_notice
 
-_LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 
-def allow_cross_origin_requests():
+def allow_cross_origin_requests() -> bool:
     """True if cross-origin requests are allowed.
 
     We only allow cross-origin requests when CORS protection has been disabled
@@ -43,7 +46,7 @@ class StaticFileHandler(tornado.web.StaticFileHandler):
 
         super().initialize(path=path, default_filename=default_filename)
 
-    def set_extra_headers(self, path):
+    def set_extra_headers(self, path: str) -> None:
         """Disable cache for HTML files.
 
         Other assets like JS and CSS are suffixed with their hash, so they can

streamlit/web/server/server.py

@@ -12,14 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import errno
 import logging
 import os
-import socket
-import ssl
 import sys
 from pathlib import Path
-from typing import Any, Awaitable, List, Optional, Union
+from typing import TYPE_CHECKING, Any, Awaitable, Final
 
 import tornado.concurrent
 import tornado.locks
@@ -27,7 +27,6 @@ import tornado.netutil
 import tornado.web
 import tornado.websocket
 from tornado.httpserver import HTTPServer
-from typing_extensions import Final
 
 from streamlit import cli_util, config, file_util, source_util, util
 from streamlit.components.v1.components import ComponentRegistry
@@ -51,11 +50,14 @@ from streamlit.web.server.routes import (
     MessageCacheHandler,
     StaticFileHandler,
 )
-from streamlit.web.server.server_util import make_url_path_regex
+from streamlit.web.server.server_util import DEVELOPMENT_PORT, make_url_path_regex
 from streamlit.web.server.stats_request_handler import StatsRequestHandler
 from streamlit.web.server.upload_file_request_handler import UploadFileRequestHandler
 
-LOGGER = get_logger(__name__)
+if TYPE_CHECKING:
+    from ssl import SSLContext
+
+_LOGGER: Final = get_logger(__name__)
 
 TORNADO_SETTINGS = {
     # Gzip HTTP responses.
@@ -74,11 +76,11 @@ TORNADO_SETTINGS = {
 
 # When server.port is not available it will look for the next available port
 # up to MAX_PORT_SEARCH_RETRIES.
-MAX_PORT_SEARCH_RETRIES = 100
+MAX_PORT_SEARCH_RETRIES: Final = 100
 
 # When server.address starts with this prefix, the server will bind
 # to an unix socket.
-UNIX_SOCKET_PREFIX = "unix://"
+UNIX_SOCKET_PREFIX: Final = "unix://"
 
 MEDIA_ENDPOINT: Final = "/media"
 UPLOAD_FILE_ENDPOINT: Final = "/_stcore/upload_file"
@@ -128,11 +130,9 @@ def start_listening(app: tornado.web.Application) -> None:
         start_listening_tcp_socket(http_server)
 
 
-def _get_ssl_options(
-    cert_file: Optional[str], key_file: Optional[str]
-) -> Union[ssl.SSLContext, None]:
+def _get_ssl_options(cert_file: str | None, key_file: str | None) -> SSLContext | None:
     if bool(cert_file) != bool(key_file):
-        LOGGER.error(
+        _LOGGER.error(
             "Options 'server.sslCertFile' and 'server.sslKeyFile' must "
             "be set together. Set missing options or delete existing options."
         )
@@ -142,12 +142,14 @@ def _get_ssl_options(
         # sufficiently user-friendly
         # FileNotFoundError: [Errno 2] No such file or directory
         if not Path(cert_file).exists():
-            LOGGER.error("Cert file '%s' does not exist.", cert_file)
+            _LOGGER.error("Cert file '%s' does not exist.", cert_file)
             sys.exit(1)
         if not Path(key_file).exists():
-            LOGGER.error("Key file '%s' does not exist.", key_file)
+            _LOGGER.error("Key file '%s' does not exist.", key_file)
             sys.exit(1)
 
+        import ssl
+
         ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
         # When the SSL certificate fails to load, an exception is raised as below,
         # but it is not sufficiently user-friendly.
@@ -155,7 +157,7 @@ def _get_ssl_options(
         try:
             ssl_ctx.load_cert_chain(cert_file, key_file)
         except ssl.SSLError:
-            LOGGER.error(
+            _LOGGER.error(
                 "Failed to load SSL certificate. Make sure "
                 "cert file '%s' and key file '%s' are correct.",
                 cert_file,
@@ -183,23 +185,30 @@ def start_listening_tcp_socket(http_server: HTTPServer) -> None:
         address = config.get_option("server.address")
         port = config.get_option("server.port")
 
+        if int(port) == DEVELOPMENT_PORT:
+            _LOGGER.warning(
+                "Port %s is reserved for internal development. "
+                "It is strongly recommended to select an alternative port "
+                "for `server.port`.",
+                DEVELOPMENT_PORT,
+            )
+
         try:
             http_server.listen(port, address)
             break  # It worked! So let's break out of the loop.
 
-        except (OSError, socket.error) as e:
+        except OSError as e:
             if e.errno == errno.EADDRINUSE:
                 if server_port_is_manually_set():
-                    LOGGER.error("Port %s is already in use", port)
+                    _LOGGER.error("Port %s is already in use", port)
                     sys.exit(1)
                 else:
-                    LOGGER.debug(
+                    _LOGGER.debug(
                         "Port %s already in use, trying to use the next one.", port
                     )
                     port += 1
-                    # Save port 3000 because it is used for the development
-                    # server in the front end.
-                    if port == 3000:
+                    # Don't use the development port here:
+                    if port == DEVELOPMENT_PORT:
                         port += 1
 
                     config.set_option(
@@ -255,13 +264,13 @@ class Server:
         When this returns, Streamlit is ready to accept new sessions.
         """
 
-        LOGGER.debug("Starting server...")
+        _LOGGER.debug("Starting server...")
 
         app = self._create_app()
         start_listening(app)
 
         port = config.get_option("server.port")
-        LOGGER.debug("Server started on port %s", port)
+        _LOGGER.debug("Server started on port %s", port)
 
         await self._runtime.start()
 
@@ -274,7 +283,7 @@ class Server:
         """Create our tornado web app."""
         base = config.get_option("server.baseUrlPath")
 
-        routes: List[Any] = [
+        routes: list[Any] = [
             (
                 make_url_path_regex(base, STREAM_ENDPOINT),
                 BrowserWebSocketHandler,
@@ -347,10 +356,10 @@ class Server:
             )
 
         if config.get_option("global.developmentMode"):
-            LOGGER.debug("Serving static content from the Node dev server")
+            _LOGGER.debug("Serving static content from the Node dev server")
         else:
             static_path = file_util.get_static_dir()
-            LOGGER.debug("Serving static content from %s", static_path)
+            _LOGGER.debug("Serving static content from %s", static_path)
 
             routes.extend(
                 [
@@ -360,14 +369,12 @@ class Server:
                         {
                             "path": "%s/" % static_path,
                             "default_filename": "index.html",
-                            "get_pages": lambda: set(
-                                [
-                                    page_info["page_name"]
-                                    for page_info in source_util.get_pages(
-                                        self.main_script_path
-                                    ).values()
-                                ]
-                            ),
+                            "get_pages": lambda: {
+                                page_info["page_name"]
+                                for page_info in source_util.get_pages(
+                                    self.main_script_path
+                                ).values()
+                            },
                         },
                     ),
                     (make_url_path_regex(base, trailing_slash=False), AddSlashHandler),