streamlit-nightly 1.33.1.dev20240416__py2.py3-none-any.whl → 1.33.1.dev20240418__py2.py3-none-any.whl

streamlit/elements/widgets/text_widgets.py

@@ -20,6 +20,7 @@ from typing import TYPE_CHECKING, Literal, cast, overload
 
 from streamlit.elements.form import current_form_id
 from streamlit.elements.utils import (
+    check_cache_replay_rules,
     check_callback_rules,
     check_session_state_rules,
     get_label_visibility_proto_value,
@@ -33,6 +34,7 @@ from streamlit.runtime.state import (
     WidgetArgs,
     WidgetCallback,
     WidgetKwargs,
+    get_session_state,
     register_widget,
 )
 from streamlit.runtime.state.common import compute_widget_id
@@ -254,9 +256,9 @@ class TextWidgetsMixin:
         ctx: ScriptRunContext | None = None,
     ) -> str | None:
         key = to_key(key)
+        check_cache_replay_rules()
         check_callback_rules(self.dg, on_change)
         check_session_state_rules(default_value=None if value == "" else value, key=key)
-
         maybe_raise_label_warnings(label, label_visibility)
 
         # Make sure value is always string or None:
@@ -277,6 +279,10 @@ class TextWidgetsMixin:
             page=ctx.page_script_hash if ctx else None,
         )
 
+        session_state = get_session_state().filtered_state
+        if key is not None and key in session_state and session_state[key] is None:
+            value = None
+
         text_input_proto = TextInputProto()
         text_input_proto.id = id
         text_input_proto.label = label
@@ -515,9 +521,10 @@ class TextWidgetsMixin:
         ctx: ScriptRunContext | None = None,
     ) -> str | None:
         key = to_key(key)
+
+        check_cache_replay_rules()
         check_callback_rules(self.dg, on_change)
         check_session_state_rules(default_value=None if value == "" else value, key=key)
-
         maybe_raise_label_warnings(label, label_visibility)
 
         value = str(value) if value is not None else None
@@ -536,6 +543,10 @@ class TextWidgetsMixin:
             page=ctx.page_script_hash if ctx else None,
         )
 
+        session_state = get_session_state().filtered_state
+        if key is not None and key in session_state and session_state[key] is None:
+            value = None
+
         text_area_proto = TextAreaProto()
         text_area_proto.id = id
         text_area_proto.label = label

streamlit/elements/widgets/time_widgets.py

@@ -21,6 +21,7 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Final,
+    List,
     Literal,
     Sequence,
     Tuple,
@@ -33,6 +34,7 @@ from typing_extensions import TypeAlias
 
 from streamlit.elements.form import current_form_id
 from streamlit.elements.utils import (
+    check_cache_replay_rules,
     check_callback_rules,
     check_session_state_rules,
     get_label_visibility_proto_value,
@@ -78,7 +80,6 @@ def _parse_date_value(
     if value == "today":
         parsed_dates = [datetime.now().date()]
     elif value == "default_value_today":
-        # Set value default.
         parsed_dates = [datetime.now().date()]
     elif isinstance(value, datetime):
         parsed_dates = [value.date()]
@@ -158,17 +159,27 @@ class _DateInputValues:
         max_value: SingleDateValue,
     ) -> _DateInputValues:
         parsed_value, is_range = _parse_date_value(value=value)
+        parsed_min = _parse_min_date(
+            min_value=min_value,
+            parsed_dates=parsed_value,
+        )
+        parsed_max = _parse_max_date(
+            max_value=max_value,
+            parsed_dates=parsed_value,
+        )
+
+        if value == "default_value_today":
+            v = cast(List[date], parsed_value)[0]
+            if v < parsed_min:
+                parsed_value = [parsed_min]
+            if v > parsed_max:
+                parsed_value = [parsed_max]
+
         return cls(
             value=parsed_value,
             is_range=is_range,
-            min=_parse_min_date(
-                min_value=min_value,
-                parsed_dates=parsed_value,
-            ),
-            max=_parse_max_date(
-                max_value=max_value,
-                parsed_dates=parsed_value,
-            ),
+            min=parsed_min,
+            max=parsed_max,
         )
 
     def __post_init__(self) -> None:
@@ -413,6 +424,7 @@ class TimeWidgetsMixin:
         ctx: ScriptRunContext | None = None,
     ) -> time | None:
         key = to_key(key)
+        check_cache_replay_rules()
         check_callback_rules(self.dg, on_change)
         check_session_state_rules(
             default_value=value if value != "now" else None, key=key
@@ -447,6 +459,10 @@ class TimeWidgetsMixin:
         )
         del value
 
+        session_state = get_session_state().filtered_state
+        if key is not None and key in session_state and session_state[key] is None:
+            parsed_time = None
+
         time_input_proto = TimeInputProto()
         time_input_proto.id = id
         time_input_proto.label = label
@@ -668,11 +684,12 @@ class TimeWidgetsMixin:
         ctx: ScriptRunContext | None = None,
     ) -> DateWidgetReturn:
         key = to_key(key)
+
+        check_cache_replay_rules()
         check_callback_rules(self.dg, on_change)
         check_session_state_rules(
             default_value=value if value != "default_value_today" else None, key=key
         )
-
         maybe_raise_label_warnings(label, label_visibility)
 
         def parse_date_deterministic(

streamlit/runtime/caching/__init__.py

@@ -14,8 +14,7 @@
 
 from __future__ import annotations
 
-import contextlib
-from typing import Any, Iterator
+from typing import Any
 
 from google.protobuf.message import Message
 
@@ -84,21 +83,6 @@ def save_media_data(image_data: bytes | str, mimetype: str, image_id: str) -> No
     CACHE_RESOURCE_MESSAGE_REPLAY_CTX.save_image_data(image_data, mimetype, image_id)
 
 
-def maybe_show_cached_st_function_warning(dg, st_func_name: str) -> None:
-    CACHE_DATA_MESSAGE_REPLAY_CTX.maybe_show_cached_st_function_warning(
-        dg, st_func_name
-    )
-    CACHE_RESOURCE_MESSAGE_REPLAY_CTX.maybe_show_cached_st_function_warning(
-        dg, st_func_name
-    )
-
-
-@contextlib.contextmanager
-def suppress_cached_st_function_warning() -> Iterator[None]:
-    with CACHE_DATA_MESSAGE_REPLAY_CTX.suppress_cached_st_function_warning(), CACHE_RESOURCE_MESSAGE_REPLAY_CTX.suppress_cached_st_function_warning():
-        yield
-
-
 # Explicitly export public symbols
 from streamlit.runtime.caching.cache_data_api import get_data_cache_stats_provider
 from streamlit.runtime.caching.cache_resource_api import (
@@ -136,8 +120,6 @@ __all__ = [
     "save_block_message",
     "save_widget_metadata",
     "save_media_data",
-    "maybe_show_cached_st_function_warning",
-    "suppress_cached_st_function_warning",
     "get_data_cache_stats_provider",
     "get_resource_cache_stats_provider",
     "cache_data",

streamlit/runtime/caching/cache_data_api.py

@@ -513,6 +513,9 @@ class CacheDataAPI:
         ...     # Fetch data from _db_connection here, and then clean it up.
         ...     return data
         ...
+        >>> fetch_and_clean_data.clear(_db_connection, 50)
+        >>> # Clear the cached entry for the arguments provided.
+        >>>
         >>> fetch_and_clean_data.clear()
         >>> # Clear all cached entries for this function.
 
@@ -701,8 +704,11 @@ class DataCache(Cache):
 
         self.storage.set(key, pickled_entry)
 
-    def _clear(self) -> None:
-        self.storage.clear()
+    def _clear(self, key: str | None = None) -> None:
+        if not key:
+            self.storage.clear()
+        else:
+            self.storage.delete(key)
 
     def _read_multi_results_from_storage(self, key: str) -> MultiCacheResults:
         """Look up the results from storage and ensure it has the right type.

streamlit/runtime/caching/cache_errors.py

@@ -96,44 +96,6 @@ class CacheError(Exception):
     pass
 
 
-class CachedStFunctionWarning(StreamlitAPIWarning):
-    def __init__(
-        self,
-        cache_type: CacheType,
-        st_func_name: str,
-        cached_func: types.FunctionType,
-    ):
-        args = {
-            "st_func_name": f"`st.{st_func_name}()`",
-            "func_name": self._get_cached_func_name_md(cached_func),
-            "decorator_name": get_decorator_api_name(cache_type),
-        }
-
-        msg = (
-            """
-Your script uses %(st_func_name)s to write to your Streamlit app from within
-some cached code at %(func_name)s. This code will only be called when we detect
-a cache "miss", which can lead to unexpected results.
-
-How to fix this:
-* Move the %(st_func_name)s call outside %(func_name)s.
-* Or, if you know what you're doing, use `@st.%(decorator_name)s(experimental_allow_widgets=True)`
-to enable widget replay and suppress this warning.
-            """
-            % args
-        ).strip("\n")
-
-        super().__init__(msg)
-
-    @staticmethod
-    def _get_cached_func_name_md(func: types.FunctionType) -> str:
-        """Get markdown representation of the function name."""
-        if hasattr(func, "__name__"):
-            return "`%s()`" % func.__name__
-        else:
-            return "a cached function"
-
-
 class CacheReplayClosureError(StreamlitAPIException):
     def __init__(
         self,

streamlit/runtime/caching/cache_resource_api.py

@@ -384,6 +384,9 @@ class CacheResourceAPI:
         ...     # Create a database connection object that points to the URL.
         ...     return connection
         ...
+        >>> fetch_and_clean_data.clear(_sessionmaker, "https://streamlit.io/")
+        >>> # Clear the cached entry for the arguments provided.
+        >>>
         >>> get_database_session.clear()
         >>> # Clear all cached entries for this function.
 
@@ -549,9 +552,12 @@ class ResourceCache(Cache):
             multi_results.results[widget_key] = result
             self._mem_cache[key] = multi_results
 
-    def _clear(self) -> None:
+    def _clear(self, key: str | None = None) -> None:
         with self._mem_cache_lock:
-            self._mem_cache.clear()
+            if key is None:
+                self._mem_cache.clear()
+            elif key in self._mem_cache:
+                del self._mem_cache[key]
 
     def get_stats(self) -> list[CacheStat]:
         # Shallow clone our cache. Computing item sizes is potentially

streamlit/runtime/caching/cache_utils.py

@@ -102,14 +102,19 @@ class Cache:
         with self._value_locks_lock:
             return self._value_locks[value_key]
 
-    def clear(self):
-        """Clear all values from this cache."""
+    def clear(self, key: str | None = None):
+        """Clear values from this cache.
+        If no argument is passed, all items are cleared from the cache.
+        A key can be passed to clear that key from the cache only."""
         with self._value_locks_lock:
-            self._value_locks.clear()
-        self._clear()
+            if not key:
+                self._value_locks.clear()
+            elif key in self._value_locks:
+                del self._value_locks[key]
+        self._clear(key=key)
 
     @abstractmethod
-    def _clear(self) -> None:
+    def _clear(self, key: str | None = None) -> None:
         """Subclasses must implement this to perform cache-clearing logic."""
         raise NotImplementedError
 
@@ -154,7 +159,7 @@ def make_cached_func_wrapper(info: CachedFuncInfo) -> Callable[..., Any]:
     value otherwise.
 
     The wrapper also has a `clear` function that can be called to clear
-    all of the wrapper's cached values.
+    some or all of the wrapper's cached values.
     """
     cached_func = CachedFunc(info)
 
@@ -303,10 +308,22 @@ class CachedFunc:
                     return_value=computed_value, func=self._info.func
                 )
 
-    def clear(self):
-        """Clear the wrapped function's associated cache."""
+    def clear(self, *args, **kwargs):
+        """Clear the wrapped function's associated cache.
+        If no arguments are passed, clear the cache of all values.
+        If args/kwargs are provided, clear the cached value for these arguments only."""
         cache = self._info.get_function_cache(self._function_key)
-        cache.clear()
+        if args or kwargs:
+            key = _make_value_key(
+                cache_type=self._info.cache_type,
+                func=self._info.func,
+                func_args=args,
+                func_kwargs=kwargs,
+                hash_funcs=self._info.hash_funcs,
+            )
+        else:
+            key = None
+        cache.clear(key=key)
 
 
 def _make_value_key(

streamlit/runtime/caching/cached_message_replay.py

@@ -33,13 +33,9 @@ from google.protobuf.message import Message
 
 import streamlit as st
 from streamlit import runtime, util
-from streamlit.elements import NONWIDGET_ELEMENTS, WIDGETS
 from streamlit.logger import get_logger
 from streamlit.proto.Block_pb2 import Block
-from streamlit.runtime.caching.cache_errors import (
-    CachedStFunctionWarning,
-    CacheReplayClosureError,
-)
+from streamlit.runtime.caching.cache_errors import CacheReplayClosureError
 from streamlit.runtime.caching.cache_type import CacheType
 from streamlit.runtime.caching.hashing import update_hash
 from streamlit.runtime.scriptrunner.script_run_context import (
@@ -239,15 +235,13 @@ class CachedMessageReplayContext(threading.local):
     """
 
     def __init__(self, cache_type: CacheType):
-        self._cached_func_stack: list[types.FunctionType] = []
-        self._suppress_st_function_warning = 0
         self._cached_message_stack: list[list[MsgData]] = []
         self._seen_dg_stack: list[set[str]] = []
         self._most_recent_messages: list[MsgData] = []
         self._registered_metadata: WidgetMetadata[Any] | None = None
         self._media_data: list[MediaMsgData] = []
         self._cache_type = cache_type
-        self._allow_widgets: int = 0
+        self._allow_widgets: bool = False
 
     def __repr__(self) -> str:
         return util.repr_(self)
@@ -260,19 +254,36 @@ class CachedMessageReplayContext(threading.local):
         It allows us to track any `st.foo` messages that are generated from inside the function
         for playback during cache retrieval.
         """
-        self._cached_func_stack.append(func)
         self._cached_message_stack.append([])
         self._seen_dg_stack.append(set())
-        if allow_widgets:
-            self._allow_widgets += 1
+        self._allow_widgets = allow_widgets
+
+        nested_call = False
+        ctx = get_script_run_ctx()
+        if ctx:
+            if ctx.disallow_cached_widget_usage:
+                # The disallow_cached_widget_usage is already set to true.
+                # This indicates that this cached function run is called from another
+                # cached function that disallows widget usage.
+                # We need to deactivate the widget usage for this cached function run
+                # even if it was allowed.
+                self._allow_widgets = False
+                nested_call = True
+
+            if not self._allow_widgets:
+                # If we're in a cached function that disallows widget usage, we need to set
+                # the disallow_cached_widget_usage to true for this cached function run
+                # to prevent widget usage (triggers a warning).
+                ctx.disallow_cached_widget_usage = True
         try:
             yield
         finally:
-            self._cached_func_stack.pop()
             self._most_recent_messages = self._cached_message_stack.pop()
             self._seen_dg_stack.pop()
-            if allow_widgets:
-                self._allow_widgets -= 1
+            if ctx and not nested_call:
+                # Reset the disallow_cached_widget_usage flag. But only if this
+                # is not nested inside a cached function that disallows widget usage.
+                ctx.disallow_cached_widget_usage = False
 
     def save_element_message(
         self,
@@ -365,59 +376,6 @@ class CachedMessageReplayContext(threading.local):
     ) -> None:
         self._media_data.append(MediaMsgData(image_data, mimetype, image_id))
 
-    @contextlib.contextmanager
-    def suppress_cached_st_function_warning(self) -> Iterator[None]:
-        self._suppress_st_function_warning += 1
-        try:
-            yield
-        finally:
-            self._suppress_st_function_warning -= 1
-            assert self._suppress_st_function_warning >= 0
-
-    def maybe_show_cached_st_function_warning(
-        self,
-        dg: DeltaGenerator,
-        st_func_name: str,
-    ) -> None:
-        """If appropriate, warn about calling st.foo inside @st.cache_data.
-
-        DeltaGenerator's @_with_element and @_widget wrappers use this to warn
-        the user when they're calling st.foo() from within a function that is
-        wrapped in @st.cache.
-
-        Parameters
-        ----------
-        dg : DeltaGenerator
-            The DeltaGenerator to publish the warning to.
-
-        st_func_name : str
-            The name of the Streamlit function that was called.
-
-        """
-        # There are some elements not in either list, which we still want to warn about.
-        # Ideally we will fix this by either updating the lists or creating a better
-        # way of categorizing elements.
-        if st_func_name in NONWIDGET_ELEMENTS:
-            return
-        if st_func_name in WIDGETS and self._allow_widgets > 0:
-            return
-
-        if len(self._cached_func_stack) > 0 and self._suppress_st_function_warning <= 0:
-            cached_func = self._cached_func_stack[-1]
-            self._show_cached_st_function_warning(dg, st_func_name, cached_func)
-
-    def _show_cached_st_function_warning(
-        self,
-        dg: DeltaGenerator,
-        st_func_name: str,
-        cached_func: types.FunctionType,
-    ) -> None:
-        # Avoid infinite recursion by suppressing additional cached
-        # function warnings from within the cached function warning.
-        with self.suppress_cached_st_function_warning():
-            e = CachedStFunctionWarning(self._cache_type, st_func_name, cached_func)
-            dg.exception(e)
-
 
 def replay_cached_messages(
     result: CachedResult, cache_type: CacheType, cached_func: types.FunctionType

streamlit/runtime/fragment.py

@@ -140,7 +140,7 @@ def fragment(
     with each fragment rerun, until the next full-script rerun.
 
     Calling `st.sidebar` in a fragment is not supported. To write elements to
-    the sidebar with a fragment, call your fragment funciton inside a
+    the sidebar with a fragment, call your fragment function inside a
     `with st.sidebar` context manager.
 
     Fragment code can interact with Session State, imported modules, and

streamlit/runtime/legacy_caching/__init__.py

@@ -12,16 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from streamlit.runtime.legacy_caching.caching import (
-    cache,
-    clear_cache,
-    get_cache_path,
-    maybe_show_cached_st_function_warning,
-)
+from streamlit.runtime.legacy_caching.caching import cache, clear_cache, get_cache_path
 
-__all__ = [
-    "cache",
-    "clear_cache",
-    "get_cache_path",
-    "maybe_show_cached_st_function_warning",
-]
+__all__ = ["cache", "clear_cache", "get_cache_path"]

streamlit/runtime/legacy_caching/caching.py

@@ -236,7 +236,6 @@ _mem_caches = _MemCaches()
 class ThreadLocalCacheInfo(threading.local):
     def __init__(self):
         self.cached_func_stack: list[Callable[..., Any]] = []
-        self.suppress_st_function_warning = 0
 
     def __repr__(self) -> str:
         return util.repr_(self)
@@ -254,54 +253,6 @@ def _calling_cached_function(func: Callable[..., Any]) -> Iterator[None]:
         _cache_info.cached_func_stack.pop()
 
 
-@contextlib.contextmanager
-def suppress_cached_st_function_warning() -> Iterator[None]:
-    _cache_info.suppress_st_function_warning += 1
-    try:
-        yield
-    finally:
-        _cache_info.suppress_st_function_warning -= 1
-        assert _cache_info.suppress_st_function_warning >= 0
-
-
-def _show_cached_st_function_warning(
-    dg: st.delta_generator.DeltaGenerator,
-    st_func_name: str,
-    cached_func: Callable[..., Any],
-) -> None:
-    # Avoid infinite recursion by suppressing additional cached
-    # function warnings from within the cached function warning.
-    with suppress_cached_st_function_warning():
-        e = CachedStFunctionWarning(st_func_name, cached_func)
-        dg.exception(e)
-
-
-def maybe_show_cached_st_function_warning(
-    dg: st.delta_generator.DeltaGenerator, st_func_name: str
-) -> None:
-    """If appropriate, warn about calling st.foo inside @cache.
-
-    DeltaGenerator's @_with_element and @_widget wrappers use this to warn
-    the user when they're calling st.foo() from within a function that is
-    wrapped in @st.cache.
-
-    Parameters
-    ----------
-    dg : DeltaGenerator
-        The DeltaGenerator to publish the warning to.
-
-    st_func_name : str
-        The name of the Streamlit function that was called.
-
-    """
-    if (
-        len(_cache_info.cached_func_stack) > 0
-        and _cache_info.suppress_st_function_warning <= 0
-    ):
-        cached_func = _cache_info.cached_func_stack[-1]
-        _show_cached_st_function_warning(dg, st_func_name, cached_func)
-
-
 def _read_from_mem_cache(
     mem_cache: MemCache,
     key: str,
@@ -683,11 +634,7 @@ def cache(
                 _LOGGER.debug("Cache miss: %s", non_optional_func)
 
                 with _calling_cached_function(non_optional_func):
-                    if suppress_st_warning:
-                        with suppress_cached_st_function_warning():
-                            return_value = non_optional_func(*args, **kwargs)
-                    else:
-                        return_value = non_optional_func(*args, **kwargs)
+                    return_value = non_optional_func(*args, **kwargs)
 
                 _write_to_cache(
                     mem_cache=mem_cache,
@@ -826,32 +773,6 @@ class CachedObjectMutationError(ValueError):
         return util.repr_(self)
 
 
-class CachedStFunctionWarning(StreamlitAPIWarning):
-    def __init__(self, st_func_name, cached_func):
-        msg = self._get_message(st_func_name, cached_func)
-        super().__init__(msg)
-
-    def _get_message(self, st_func_name, cached_func):
-        args = {
-            "st_func_name": "`st.%s()` or `st.write()`" % st_func_name,
-            "func_name": _get_cached_func_name_md(cached_func),
-        }
-
-        return (
-            """
-Your script uses %(st_func_name)s to write to your Streamlit app from within
-some cached code at %(func_name)s. This code will only be called when we detect
-a cache "miss", which can lead to unexpected results.
-
-How to fix this:
-* Move the %(st_func_name)s call outside %(func_name)s.
-* Or, if you know what you're doing, use `@st.cache(suppress_st_warning=True)`
-to suppress the warning.
-            """
-            % args
-        ).strip("\n")
-
-
 class CachedObjectMutationWarning(StreamlitAPIWarning):
     def __init__(self, orig_exc):
         msg = self._get_message(orig_exc)

streamlit/runtime/scriptrunner/script_run_context.py

@@ -79,6 +79,9 @@ class ScriptRunContext:
     fragment_ids_this_run: set[str] | None = None
     # we allow only one dialog to be open at the same time
     has_dialog_opened: bool = False
+    # If true, it indicates that we are in a cached function that disallows
+    # the usage of widgets.
+    disallow_cached_widget_usage: bool = False
 
     # TODO(willhuang1997): Remove this variable when experimental query params are removed
     _experimental_query_params_used = False
@@ -105,6 +108,7 @@ class ScriptRunContext:
         self.current_fragment_id = None
         self.fragment_ids_this_run = fragment_ids_this_run
         self.has_dialog_opened = False
+        self.disallow_cached_widget_usage = False
 
         parsed_query_params = parse.parse_qs(query_string, keep_blank_values=True)
         with self.session_state.query_params() as qp:

streamlit/static/asset-manifest.json

@@ -1,7 +1,7 @@
 {
   "files": {
     "main.css": "./static/css/main.bf304093.css",
-    "main.js": "./static/js/main.713dd29d.js",
+    "main.js": "./static/js/main.81ad100d.js",
     "static/js/9336.2d95d840.chunk.js": "./static/js/9336.2d95d840.chunk.js",
     "static/js/9330.d29313d4.chunk.js": "./static/js/9330.d29313d4.chunk.js",
     "static/js/7217.d970c074.chunk.js": "./static/js/7217.d970c074.chunk.js",
@@ -9,7 +9,7 @@
     "static/css/3092.95a45cfe.chunk.css": "./static/css/3092.95a45cfe.chunk.css",
     "static/js/3092.152fd2b7.chunk.js": "./static/js/3092.152fd2b7.chunk.js",
     "static/css/43.e3b876c5.chunk.css": "./static/css/43.e3b876c5.chunk.css",
-    "static/js/43.9ae03282.chunk.js": "./static/js/43.9ae03282.chunk.js",
+    "static/js/43.b0aa5759.chunk.js": "./static/js/43.b0aa5759.chunk.js",
     "static/js/8427.d30dffe1.chunk.js": "./static/js/8427.d30dffe1.chunk.js",
     "static/js/7323.2808d029.chunk.js": "./static/js/7323.2808d029.chunk.js",
     "static/js/4185.935c68ec.chunk.js": "./static/js/4185.935c68ec.chunk.js",
@@ -152,6 +152,6 @@
   },
   "entrypoints": [
     "static/css/main.bf304093.css",
-    "static/js/main.713dd29d.js"
+    "static/js/main.81ad100d.js"
   ]
 }

streamlit/static/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no"/><link rel="shortcut icon" href="./favicon.png"/><link rel="preload" href="./static/media/SourceSansPro-Regular.0d69e5ff5e92ac64a0c9.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-SemiBold.abed79cd0df1827e18cf.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-Bold.118dea98980e20a81ced.woff2" as="font" type="font/woff2" crossorigin><title>Streamlit</title><script>window.prerenderReady=!1</script><script defer="defer" src="./static/js/main.713dd29d.js"></script><link href="./static/css/main.bf304093.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="UTF-8"/><meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no"/><link rel="shortcut icon" href="./favicon.png"/><link rel="preload" href="./static/media/SourceSansPro-Regular.0d69e5ff5e92ac64a0c9.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-SemiBold.abed79cd0df1827e18cf.woff2" as="font" type="font/woff2" crossorigin><link rel="preload" href="./static/media/SourceSansPro-Bold.118dea98980e20a81ced.woff2" as="font" type="font/woff2" crossorigin><title>Streamlit</title><script>window.prerenderReady=!1</script><script defer="defer" src="./static/js/main.81ad100d.js"></script><link href="./static/css/main.bf304093.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>