streamlit-nightly 1.31.1.dev20240206__py2.py3-none-any.whl → 1.31.1.dev20240208__py2.py3-none-any.whl

streamlit/runtime/caching/storage/in_memory_cache_storage_wrapper.py

@@ -16,8 +16,6 @@ from __future__ import annotations
 import math
 import threading
 
-from cachetools import TTLCache
-
 from streamlit.logger import get_logger
 from streamlit.runtime.caching import cache_utils
 from streamlit.runtime.caching.storage.cache_storage_protocol import (
@@ -26,6 +24,7 @@ from streamlit.runtime.caching.storage.cache_storage_protocol import (
     CacheStorageKeyNotFoundError,
 )
 from streamlit.runtime.stats import CacheStat
+from streamlit.util import TimedCleanupCache
 
 _LOGGER = get_logger(__name__)
 
@@ -62,7 +61,7 @@ class InMemoryCacheStorageWrapper(CacheStorage):
         self.function_display_name = context.function_display_name
         self._ttl_seconds = context.ttl_seconds
         self._max_entries = context.max_entries
-        self._mem_cache: TTLCache[str, bytes] = TTLCache(
+        self._mem_cache: TimedCleanupCache[str, bytes] = TimedCleanupCache(
             maxsize=self.max_entries,
             ttl=self.ttl_seconds,
             timer=cache_utils.TTLCACHE_TIMER,

streamlit/runtime/legacy_caching/caching.py

@@ -30,6 +30,7 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Final,
     Iterator,
     List,
     Optional,
@@ -58,9 +59,8 @@ from streamlit.runtime.legacy_caching.hashing import (
 from streamlit.runtime.metrics_util import gather_metrics
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider
 from streamlit.util import HASHLIB_KWARGS
-from streamlit.vendor.pympler.asizeof import asizeof
 
-_LOGGER = get_logger(__name__)
+_LOGGER: Final = get_logger(__name__)
 
 # The timer function we use with TTLCache. This is the default timer func, but
 # is exposed here as a constant so that it can be patched in unit tests.
@@ -226,6 +226,9 @@ class _MemCaches(CacheStatsProvider):
             # lock during stats-gathering.
             function_caches = self._function_caches.copy()
 
+        # Lazy-load vendored package to prevent import of numpy
+        from streamlit.vendor.pympler.asizeof import asizeof
+
         stats = [
             CacheStat("st_cache", cache.display_name, asizeof(c))
             for cache in function_caches.values()

streamlit/runtime/memory_session_storage.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, MutableMapping, Optional
 
-from cachetools import TTLCache
+from typing import List, MutableMapping, Optional
 
 from streamlit.runtime.session_manager import SessionInfo, SessionStorage
+from streamlit.util import TimedCleanupCache
 
 
 class MemorySessionStorage(SessionStorage):
@@ -55,7 +55,7 @@ class MemorySessionStorage(SessionStorage):
             inaccessible and will be removed eventually.
         """
 
-        self._cache: MutableMapping[str, SessionInfo] = TTLCache(
+        self._cache: MutableMapping[str, SessionInfo] = TimedCleanupCache(
             maxsize=maxsize, ttl=ttl_seconds
         )
 

streamlit/runtime/scriptrunner/script_runner.py

@@ -394,203 +394,210 @@ class ScriptRunner:
         """
         assert self._is_in_script_thread()
 
-        _LOGGER.debug("Running script %s", rerun_data)
-
-        start_time: float = timer()
-        prep_time: float = 0  # This will be overwritten once preparations are done.
-
-        # Reset DeltaGenerators, widgets, media files.
-        runtime.get_instance().media_file_mgr.clear_session_refs()
-
-        main_script_path = self._main_script_path
-        pages = source_util.get_pages(main_script_path)
-        # Safe because pages will at least contain the app's main page.
-        main_page_info = list(pages.values())[0]
-        current_page_info = None
-        uncaught_exception = None
-
-        if rerun_data.page_script_hash:
-            current_page_info = pages.get(rerun_data.page_script_hash, None)
-        elif not rerun_data.page_script_hash and rerun_data.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.
-            current_page_info = 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"] == rerun_data.page_name),
-                    pages.values(),
-                ),
-                None,
+        # An explicit loop instead of recursion to avoid stack overflows
+        while True:
+            _LOGGER.debug("Running script %s", rerun_data)
+            start_time: float = timer()
+            prep_time: float = 0  # This will be overwritten once preparations are done.
+
+            # Reset DeltaGenerators, widgets, media files.
+            runtime.get_instance().media_file_mgr.clear_session_refs()
+
+            main_script_path = self._main_script_path
+            pages = source_util.get_pages(main_script_path)
+            # Safe because pages will at least contain the app's main page.
+            main_page_info = list(pages.values())[0]
+            current_page_info = None
+            uncaught_exception = None
+
+            if rerun_data.page_script_hash:
+                current_page_info = pages.get(rerun_data.page_script_hash, None)
+            elif not rerun_data.page_script_hash and rerun_data.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.
+                current_page_info = 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"] == rerun_data.page_name),
+                        pages.values(),
+                    ),
+                    None,
+                )
+            else:
+                # If no information about what page to run is given, default to
+                # running the main page.
+                current_page_info = main_page_info
+
+            page_script_hash = (
+                current_page_info["page_script_hash"]
+                if current_page_info is not None
+                else main_page_info["page_script_hash"]
             )
-        else:
-            # If no information about what page to run is given, default to
-            # running the main page.
-            current_page_info = main_page_info
-
-        page_script_hash = (
-            current_page_info["page_script_hash"]
-            if current_page_info is not None
-            else main_page_info["page_script_hash"]
-        )
 
-        ctx = self._get_script_run_ctx()
-        ctx.reset(
-            query_string=rerun_data.query_string,
-            page_script_hash=page_script_hash,
-        )
-
-        self.on_event.send(
-            self,
-            event=ScriptRunnerEvent.SCRIPT_STARTED,
-            page_script_hash=page_script_hash,
-        )
+            ctx = self._get_script_run_ctx()
+            ctx.reset(
+                query_string=rerun_data.query_string,
+                page_script_hash=page_script_hash,
+            )
 
-        # Compile the script. Any errors thrown here will be surfaced
-        # to the user via a modal dialog in the frontend, and won't result
-        # in their previous script elements disappearing.
-        try:
-            if current_page_info:
-                script_path = current_page_info["script_path"]
-            else:
-                script_path = main_script_path
-
-                # At this point, we know that either
-                #   * the script corresponding to the hash requested no longer
-                #     exists, or
-                #   * we were not able to find a script with the requested page
-                #     name.
-                # In both of these cases, we want to send a page_not_found
-                # message to the frontend.
-                msg = ForwardMsg()
-                msg.page_not_found.page_name = rerun_data.page_name
-                ctx.enqueue(msg)
-
-            code = self._script_cache.get_bytecode(script_path)
-
-        except Exception as ex:
-            # We got a compile error. Send an error event and bail immediately.
-            _LOGGER.debug("Fatal script error: %s", ex)
-            self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = False
             self.on_event.send(
                 self,
-                event=ScriptRunnerEvent.SCRIPT_STOPPED_WITH_COMPILE_ERROR,
-                exception=ex,
+                event=ScriptRunnerEvent.SCRIPT_STARTED,
+                page_script_hash=page_script_hash,
             )
-            return
 
-        # If we get here, we've successfully compiled our script. The next step
-        # is to run it. Errors thrown during execution will be shown to the
-        # user as ExceptionElements.
-
-        if config.get_option("runner.installTracer"):
-            self._install_tracer()
-
-        # This will be set to a RerunData instance if our execution
-        # is interrupted by a RerunException.
-        rerun_exception_data: Optional[RerunData] = None
-
-        # If the script stops early, we don't want to remove unseen widgets,
-        # so we track this to potentially skip session state cleanup later.
-        premature_stop: bool = False
+            # Compile the script. Any errors thrown here will be surfaced
+            # to the user via a modal dialog in the frontend, and won't result
+            # in their previous script elements disappearing.
+            try:
+                if current_page_info:
+                    script_path = current_page_info["script_path"]
+                else:
+                    script_path = main_script_path
+
+                    # At this point, we know that either
+                    #   * the script corresponding to the hash requested no longer
+                    #     exists, or
+                    #   * we were not able to find a script with the requested page
+                    #     name.
+                    # In both of these cases, we want to send a page_not_found
+                    # message to the frontend.
+                    msg = ForwardMsg()
+                    msg.page_not_found.page_name = rerun_data.page_name
+                    ctx.enqueue(msg)
+
+                code = self._script_cache.get_bytecode(script_path)
+
+            except Exception as ex:
+                # We got a compile error. Send an error event and bail immediately.
+                _LOGGER.debug("Fatal script error: %s", ex)
+                self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = False
+                self.on_event.send(
+                    self,
+                    event=ScriptRunnerEvent.SCRIPT_STOPPED_WITH_COMPILE_ERROR,
+                    exception=ex,
+                )
+                return
+
+            # If we get here, we've successfully compiled our script. The next step
+            # is to run it. Errors thrown during execution will be shown to the
+            # user as ExceptionElements.
+
+            if config.get_option("runner.installTracer"):
+                self._install_tracer()
+
+            # This will be set to a RerunData instance if our execution
+            # is interrupted by a RerunException.
+            rerun_exception_data: Optional[RerunData] = None
+
+            # If the script stops early, we don't want to remove unseen widgets,
+            # so we track this to potentially skip session state cleanup later.
+            premature_stop: bool = False
+
+            try:
+                # Create fake module. This gives us a name global namespace to
+                # execute the code in.
+                # TODO(vdonato): Double-check that we're okay with naming the
+                # module for every page `__main__`. I'm pretty sure this is
+                # necessary given that people will likely often write
+                #     ```
+                #     if __name__ == "__main__":
+                #         ...
+                #     ```
+                # in their scripts.
+                module = _new_module("__main__")
+
+                # Install the fake module as the __main__ module. This allows
+                # the pickle module to work inside the user's code, since it now
+                # can know the module where the pickled objects stem from.
+                # IMPORTANT: This means we can't use "if __name__ == '__main__'" in
+                # our code, as it will point to the wrong module!!!
+                sys.modules["__main__"] = module
+
+                # Add special variables to the module's globals dict.
+                # Note: The following is a requirement for the CodeHasher to
+                # work correctly. The CodeHasher is scoped to
+                # files contained in the directory of __main__.__file__, which we
+                # assume is the main script directory.
+                module.__dict__["__file__"] = script_path
+
+                with modified_sys_path(
+                    self._main_script_path
+                ), self._set_execing_flag():
+                    # Run callbacks for widgets whose values have changed.
+                    if rerun_data.widget_states is not None:
+                        self._session_state.on_script_will_rerun(
+                            rerun_data.widget_states
+                        )
 
-        try:
-            # Create fake module. This gives us a name global namespace to
-            # execute the code in.
-            # TODO(vdonato): Double-check that we're okay with naming the
-            # module for every page `__main__`. I'm pretty sure this is
-            # necessary given that people will likely often write
-            #     ```
-            #     if __name__ == "__main__":
-            #         ...
-            #     ```
-            # in their scripts.
-            module = _new_module("__main__")
-
-            # Install the fake module as the __main__ module. This allows
-            # the pickle module to work inside the user's code, since it now
-            # can know the module where the pickled objects stem from.
-            # IMPORTANT: This means we can't use "if __name__ == '__main__'" in
-            # our code, as it will point to the wrong module!!!
-            sys.modules["__main__"] = module
-
-            # Add special variables to the module's globals dict.
-            # Note: The following is a requirement for the CodeHasher to
-            # work correctly. The CodeHasher is scoped to
-            # files contained in the directory of __main__.__file__, which we
-            # assume is the main script directory.
-            module.__dict__["__file__"] = script_path
-
-            with modified_sys_path(self._main_script_path), self._set_execing_flag():
-                # Run callbacks for widgets whose values have changed.
-                if rerun_data.widget_states is not None:
-                    self._session_state.on_script_will_rerun(rerun_data.widget_states)
-
-                ctx.on_script_start()
-                prep_time = timer() - start_time
-                exec(code, module.__dict__)
-                self._session_state.maybe_check_serializable()
-                self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = True
-        except RerunException as e:
-            rerun_exception_data = e.rerun_data
-            # Interruption due to a rerun is usually from `st.rerun()`, which
-            # we want to count as a script completion so triggers reset.
-            # It is also possible for this to happen if fast reruns is off,
-            # but this is very rare.
-            premature_stop = False
-
-        except StopException:
-            # This is thrown when the script executes `st.stop()`.
-            # We don't have to do anything here.
-            premature_stop = True
-
-        except Exception as ex:
-            self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = False
-            uncaught_exception = ex
-            handle_uncaught_app_exception(uncaught_exception)
-            premature_stop = True
+                    ctx.on_script_start()
+                    prep_time = timer() - start_time
+                    exec(code, module.__dict__)
+                    self._session_state.maybe_check_serializable()
+                    self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = True
+            except RerunException as e:
+                rerun_exception_data = e.rerun_data
+                # Interruption due to a rerun is usually from `st.rerun()`, which
+                # we want to count as a script completion so triggers reset.
+                # It is also possible for this to happen if fast reruns is off,
+                # but this is very rare.
+                premature_stop = False
+
+            except StopException:
+                # This is thrown when the script executes `st.stop()`.
+                # We don't have to do anything here.
+                premature_stop = True
+
+            except Exception as ex:
+                self._session_state[SCRIPT_RUN_WITHOUT_ERRORS_KEY] = False
+                uncaught_exception = ex
+                handle_uncaught_app_exception(uncaught_exception)
+                premature_stop = True
+
+            finally:
+                if rerun_exception_data:
+                    finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_FOR_RERUN
+                else:
+                    finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
+
+                if ctx.gather_usage_stats:
+                    try:
+                        # Prevent issues with circular import
+                        from streamlit.runtime.metrics_util import (
+                            create_page_profile_message,
+                            to_microseconds,
+                        )
 
-        finally:
-            if rerun_exception_data:
-                finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_FOR_RERUN
-            else:
-                finished_event = ScriptRunnerEvent.SCRIPT_STOPPED_WITH_SUCCESS
-
-            if ctx.gather_usage_stats:
-                try:
-                    # Prevent issues with circular import
-                    from streamlit.runtime.metrics_util import (
-                        create_page_profile_message,
-                        to_microseconds,
-                    )
-
-                    # Create and send page profile information
-                    ctx.enqueue(
-                        create_page_profile_message(
-                            ctx.tracked_commands,
-                            exec_time=to_microseconds(timer() - start_time),
-                            prep_time=to_microseconds(prep_time),
-                            uncaught_exception=type(uncaught_exception).__name__
-                            if uncaught_exception
-                            else None,
+                        # Create and send page profile information
+                        ctx.enqueue(
+                            create_page_profile_message(
+                                ctx.tracked_commands,
+                                exec_time=to_microseconds(timer() - start_time),
+                                prep_time=to_microseconds(prep_time),
+                                uncaught_exception=type(uncaught_exception).__name__
+                                if uncaught_exception
+                                else None,
+                            )
                         )
-                    )
-                except Exception as ex:
-                    # Always capture all exceptions since we want to make sure that
-                    # the telemetry never causes any issues.
-                    _LOGGER.debug("Failed to create page profile", exc_info=ex)
-            self._on_script_finished(ctx, finished_event, premature_stop)
-
-        # Use _log_if_error() to make sure we never ever ever stop running the
-        # script without meaning to.
-        _log_if_error(_clean_problem_modules)
-
-        if rerun_exception_data is not None:
-            self._run_script(rerun_exception_data)
+                    except Exception as ex:
+                        # Always capture all exceptions since we want to make sure that
+                        # the telemetry never causes any issues.
+                        _LOGGER.debug("Failed to create page profile", exc_info=ex)
+                self._on_script_finished(ctx, finished_event, premature_stop)
+
+            # Use _log_if_error() to make sure we never ever ever stop running the
+            # script without meaning to.
+            _log_if_error(_clean_problem_modules)
+
+            if rerun_exception_data is not None:
+                rerun_data = rerun_exception_data
+            else:
+                break
 
     def _on_script_finished(
         self, ctx: ScriptRunContext, event: ScriptRunnerEvent, premature_stop: bool

streamlit/runtime/state/session_state.py

@@ -11,6 +11,7 @@
 # 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 json
@@ -20,6 +21,7 @@ from dataclasses import dataclass, field, replace
 from typing import (
     TYPE_CHECKING,
     Any,
+    Final,
     Iterator,
     KeysView,
     List,
@@ -28,7 +30,7 @@ from typing import (
     cast,
 )
 
-from typing_extensions import Final, TypeAlias
+from typing_extensions import TypeAlias
 
 import streamlit as st
 from streamlit import config, util
@@ -45,7 +47,6 @@ from streamlit.runtime.state.common import (
 from streamlit.runtime.state.query_params import QueryParams
 from streamlit.runtime.stats import CacheStat, CacheStatsProvider, group_stats
 from streamlit.type_util import ValueFieldName, is_array_value_field_name
-from streamlit.vendor.pympler.asizeof import asizeof
 
 if TYPE_CHECKING:
     from streamlit.runtime.session_manager import SessionManager
@@ -637,6 +638,9 @@ class SessionState:
             return True
 
     def get_stats(self) -> list[CacheStat]:
+        # Lazy-load vendored package to prevent import of numpy
+        from streamlit.vendor.pympler.asizeof import asizeof
+
         stat = CacheStat("st_session_state", "", asizeof(self))
         return [stat]
 

streamlit/string_util.py

@@ -12,22 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import re
 import textwrap
-from typing import TYPE_CHECKING, Any, Optional, Tuple, cast
+from typing import TYPE_CHECKING, Any, Tuple, cast
 
-from streamlit.emojis import ALL_EMOJIS
 from streamlit.errors import StreamlitAPIException
 
 if TYPE_CHECKING:
     from streamlit.type_util import SupportsStr
 
-
-# The ESCAPED_EMOJI list is sorted in descending order to make that longer emoji appear
-# first in the regex compiled below. This ensures that we grab the full emoji in a
-# multi-character emoji sequence that starts with a shorter emoji (emoji are weird...).
-ESCAPED_EMOJI = [re.escape(e) for e in sorted(ALL_EMOJIS, reverse=True)]
-EMOJI_EXTRACTION_REGEX = re.compile(f"^({'|'.join(ESCAPED_EMOJI)})[_ -]*(.*)")
+_ALPHANUMERIC_CHAR_REGEX = re.compile(r"^[a-zA-Z0-9_&\-\. ]+$")
 
 
 def decode_ascii(string: bytes) -> str:
@@ -40,14 +36,29 @@ def clean_text(text: "SupportsStr") -> str:
     return textwrap.dedent(str(text)).strip()
 
 
+def _contains_special_chars(text: str) -> bool:
+    """Check if a string contains any special chars.
+
+    Special chars in that case are all chars that are not
+    alphanumeric, underscore, hyphen or whitespace.
+    """
+    return re.match(_ALPHANUMERIC_CHAR_REGEX, text) is None if text else False
+
+
 def is_emoji(text: str) -> bool:
     """Check if input string is a valid emoji."""
+    if not _contains_special_chars(text):
+        return False
+
+    from streamlit.emojis import ALL_EMOJIS
+
     return text.replace("\U0000FE0F", "") in ALL_EMOJIS
 
 
-def validate_emoji(maybe_emoji: Optional[str]) -> str:
+def validate_emoji(maybe_emoji: str | None) -> str:
     if maybe_emoji is None:
         return ""
+
     elif is_emoji(maybe_emoji):
         return maybe_emoji
     else:
@@ -60,6 +71,15 @@ def extract_leading_emoji(text: str) -> Tuple[str, str]:
     """Return a tuple containing the first emoji found in the given string and
     the rest of the string (minus an optional separator between the two).
     """
+
+    if not _contains_special_chars(text):
+        # If the string only contains basic alphanumerical chars and/or
+        # underscores, hyphen & whitespaces, then it's guaranteed that there
+        # is no emoji in the string.
+        return "", text
+
+    from streamlit.emojis import EMOJI_EXTRACTION_REGEX
+
     re_match = re.search(EMOJI_EXTRACTION_REGEX, text)
     if re_match is None:
         return "", text
@@ -98,7 +118,7 @@ def escape_markdown(raw_string: str) -> str:
 TEXTCHARS = bytearray({7, 8, 9, 10, 12, 13, 27} | set(range(0x20, 0x100)) - {0x7F})
 
 
-def is_binary_string(inp):
+def is_binary_string(inp: bytes) -> bool:
     """Guess if an input bytesarray can be encoded as a string."""
     # From https://stackoverflow.com/a/7392391
     return bool(inp.translate(None, TEXTCHARS))