solara-ui 1.41.0__py2.py3-none-any.whl → 1.42.0__py2.py3-none-any.whl

solara/reactive.py

@@ -1,13 +1,14 @@
-from typing import TypeVar
+from typing import Any, Callable, TypeVar
 
 from solara.toestand import Reactive
+import solara.util
 
 __all__ = ["reactive", "Reactive"]
 
 T = TypeVar("T")
 
 
-def reactive(value: T) -> Reactive[T]:
+def reactive(value: T, equals: Callable[[Any, Any], bool] = solara.util.equals_extra) -> Reactive[T]:
     """Creates a new Reactive object with the given initial value.
 
     Reactive objects are mostly used to manage global or application-wide state in
@@ -35,6 +36,11 @@ def reactive(value: T) -> Reactive[T]:
 
     Args:
         value (T): The initial value of the reactive variable.
+        equals: A function that returns True if two values are considered equal, and False otherwise.
+            The default function is `solara.util.equals`, which performs a deep comparison of the two values
+            and is more forgiving than the default `==` operator.
+            You can provide a custom function if you need to define a different notion of equality.
+
 
     Returns:
         Reactive[T]: A new Reactive object with the specified initial value.
@@ -90,4 +96,4 @@ def reactive(value: T) -> Reactive[T]:
     Whenever the counter value changes, `CounterDisplay` automatically updates to display the new value.
 
     """
-    return Reactive(value)
+    return Reactive(value, equals=equals)

solara/server/kernel.py

@@ -2,6 +2,7 @@ import json
 import logging
 import pdb
 import queue
+import re
 import struct
 import warnings
 from binascii import b2a_base64
@@ -73,7 +74,7 @@ def json_dumps(data):
     )
 
 
-ipykernel_version = tuple(map(int, ipykernel.__version__.split(".")))
+ipykernel_version = tuple(map(int, re.split(r"\D+", ipykernel.__version__)[:3]))
 if ipykernel_version >= (6, 18, 0):
     import comm.base_comm
 

solara/server/qt.py

@@ -81,7 +81,7 @@ class QWebEngineViewWithPopup(QWebEngineView):
 
 
 def run_qt(url):
-    app = QApplication([])
+    app = QApplication(["Solara App"])
     web = QWebEngineViewWithPopup()
     web.setUrl(QtCore.QUrl(url))
     web.resize(1024, 1024)

solara/server/starlette.py

@@ -86,8 +86,8 @@ prefix = ""
 # Since starlette seems to accept really large values for http, lets do the same for websockets
 # An arbitrarily large value we settled on for now is 32kb
 # If we don't do this, users with many cookies will fail to get a websocket connection.
-ws_version = tuple(map(int, websockets.__version__.split(".")))
-if ws_version[0] >= 13:
+ws_major_version = int(websockets.__version__.split(".")[0])
+if ws_major_version >= 13:
     websockets.legacy.http.MAX_LINE_LENGTH = int(os.environ.get("WEBSOCKETS_MAX_LINE_LENGTH", str(1024 * 32)))  # type: ignore
 else:
     websockets.legacy.http.MAX_LINE = 1024 * 32  # type: ignore

solara/server/static/solara_bootstrap.py

@@ -119,7 +119,7 @@ async def main():
     ]
     for dep in requirements:
         await micropip.install(dep, keep_going=True)
-    await micropip.install("/wheels/solara-1.41.0-py2.py3-none-any.whl", keep_going=True)
+    await micropip.install("/wheels/solara-1.42.0-py2.py3-none-any.whl", keep_going=True)
     import solara
 
     el = solara.Warning("lala")

solara/settings.py

@@ -61,9 +61,23 @@ class MainSettings(BaseSettings):
         env_file = ".env"
 
 
+class Storage(BaseSettings):
+    mutation_detection: Optional[bool] = None  # True/False, or None to auto determine
+    factory: str = "solara.toestand.default_storage"
+
+    def get_factory(self):
+        return solara.util.import_item(self.factory)
+
+    class Config:
+        env_prefix = "solara_storage_"
+        case_sensitive = False
+        env_file = ".env"
+
+
 assets: Assets = Assets()
 cache: Cache = Cache()
 main = MainSettings()
+storage = Storage()
 
 if main.check_hooks not in ["off", "warn", "raise"]:
     raise ValueError(f"Invalid value for check_hooks: {main.check_hooks}, expected one of ['off', 'warn', 'raise']")

solara/template/portal/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling >=0.25"]
+requires = ["hatchling==1.26.3"]
 build-backend = "hatchling.build"
 
 [project]

solara/test/pytest_plugin.py

@@ -515,6 +515,8 @@ def create_runner_solara(solara_server, solara_app, page_session: "playwright.sy
 
     def run(f: Callable, locals={}):
         nonlocal count
+        from IPython.display import clear_output
+
         path = Path(f.__code__.co_filename)
         cwd = str(path.parent)
         current_dir = os.getcwd()
@@ -523,6 +525,7 @@ def create_runner_solara(solara_server, solara_app, page_session: "playwright.sy
 
         sys.path.append(cwd)
         try:
+            clear_output()
             f()
         finally:
             os.chdir(current_dir)

solara/toestand.py

@@ -1,9 +1,13 @@
 import contextlib
 import dataclasses
+import inspect
 import logging
+import os
 import sys
 import threading
+from types import FrameType
 import warnings
+import copy
 from abc import ABC, abstractmethod
 from collections import defaultdict
 from operator import getitem
@@ -24,9 +28,10 @@ from typing import (
 
 import react_ipywidgets as react
 import reacton.core
-from reacton.utils import equals
+from solara.util import equals_extra
 
 import solara
+import solara.settings
 from solara import _using_solara_server
 
 T = TypeVar("T")
@@ -61,7 +66,7 @@ def use_sync_external_store(subscribe: Callable[[Callable[[], None]], Callable[[
 
     def on_store_change(_ignore_new_state=None):
         new_state = get_snapshot()
-        if not equals(new_state, prev_state.current):
+        if not equals_extra(new_state, prev_state.current):
             prev_state.current = new_state
             force_update()
 
@@ -87,8 +92,9 @@ def merge_state(d1: S, **kwargs) -> S:
 
 
 class ValueBase(Generic[T]):
-    def __init__(self, merge: Callable = merge_state):
+    def __init__(self, merge: Callable = merge_state, equals=equals_extra):
         self.merge = merge
+        self.equals = equals
         self.listeners: Dict[str, Set[Tuple[Callable[[T], None], Optional[ContextManager]]]] = defaultdict(set)
         self.listeners2: Dict[str, Set[Tuple[Callable[[T, T], None], Optional[ContextManager]]]] = defaultdict(set)
 
@@ -199,8 +205,8 @@ class KernelStore(ValueBase[S], ABC):
     _type_counter: Dict[Any, int] = defaultdict(int)
     scope_lock = threading.RLock()
 
-    def __init__(self, key=None):
-        super().__init__()
+    def __init__(self, key=None, equals: Callable[[Any, Any], bool] = equals_extra):
+        super().__init__(equals=equals)
         self.storage_key = key
         self._global_dict = {}
         # since a set can trigger events, which can trigger new updates, we need a recursive lock
@@ -250,7 +256,7 @@ class KernelStore(ValueBase[S], ABC):
     def set(self, value: S):
         scope_dict, scope_id = self._get_dict()
         old = self.get()
-        if equals(old, value):
+        if self.equals(old, value):
             return
         scope_dict[self.storage_key] = value
 
@@ -268,23 +274,114 @@ class KernelStore(ValueBase[S], ABC):
     def initial_value(self) -> S:
         pass
 
+    def _check_mutation(self):
+        pass
+
+
+def _is_internal_module(file_name: str):
+    file_name_parts = file_name.split(os.sep)
+    if len(file_name_parts) < 2:
+        return False
+    return (
+        file_name_parts[-2:] == ["solara", "toestand.py"]
+        or file_name_parts[-2:] == ["solara", "reactive.py"]
+        or file_name_parts[-2:] == ["solara", "use_reactive.py"]
+        or file_name_parts[-2:] == ["reacton", "core.py"]
+        # If we use SomeClass[K](...) we go via the typing module, so we need to skip that as well
+        or (file_name_parts[-2].startswith("python") and file_name_parts[-1] == "typing.py")
+    )
+
+
+def _find_outside_solara_frame() -> Optional[FrameType]:
+    # the module where the call stack origined from
+    current_frame: Optional[FrameType] = None
+    module_frame = None
+
+    # _getframe is not guaranteed to exist in all Python implementations,
+    # but is much faster than the inspect module
+    if hasattr(sys, "_getframe"):
+        current_frame = sys._getframe(1)
+    else:
+        current_frame = inspect.currentframe()
+
+    while current_frame is not None:
+        file_name = current_frame.f_code.co_filename
+        # Skip most common cases, i.e. toestand.py, reactive.py, use_reactive.py, Reacton's core.py, and the typing module
+        if not _is_internal_module(file_name):
+            module_frame = current_frame
+            break
+        current_frame = current_frame.f_back
+
+    return module_frame
+
 
 class KernelStoreValue(KernelStore[S]):
     default_value: S
+    _traceback: Optional[inspect.Traceback]
+    _default_value_copy: Optional[S]
 
-    def __init__(self, default_value: S, key=None):
+    def __init__(self, default_value: S, key=None, equals: Callable[[Any, Any], bool] = equals_extra, unwrap=lambda x: x):
         self.default_value = default_value
+        self._unwrap = unwrap
+        self.equals = equals
+        self._mutation_detection = solara.settings.storage.mutation_detection
+        if self._mutation_detection:
+            frame = _find_outside_solara_frame()
+            if frame is not None:
+                self._traceback = inspect.getframeinfo(frame)
+            else:
+                self._traceback = None
+            self._default_value_copy = copy.deepcopy(default_value)
+            if not self.equals(self._unwrap(self.default_value), self._unwrap(self._default_value_copy)):
+                msg = """The equals function for this reactive value returned False when comparing a deepcopy to itself.
+
+This reactive variable will not be able to detect mutations correctly, and is therefore disabled.
+
+To avoid this warning, and to ensure that mutation detection works correctly, please provide a better equals function to the reactive variable.
+A good choice for dataframes and numpy arrays might be solara.util.equals_pickle, which will also attempt to compare the pickled values of the objects.
+
+Example:
+df = pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]})
+reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
+"""
+                tb = self._traceback
+                if tb:
+                    if tb.code_context:
+                        code = tb.code_context[0]
+                    else:
+                        code = "<No code context available>"
+                    msg += "This warning was triggered from:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                warnings.warn(msg)
+                self._mutation_detection = False
         cls = type(default_value)
         if key is None:
             with KernelStoreValue.scope_lock:
                 index = self._type_counter[cls]
                 self._type_counter[cls] += 1
             key = cls.__module__ + ":" + cls.__name__ + ":" + str(index)
-        super().__init__(key=key)
+        super().__init__(key=key, equals=equals)
 
     def initial_value(self) -> S:
+        self._check_mutation()
         return self.default_value
 
+    def _check_mutation(self):
+        if not self._mutation_detection:
+            return
+        initial = self._unwrap(self._default_value_copy)
+        current = self._unwrap(self.default_value)
+        if not self.equals(initial, current):
+            tb = self._traceback
+            if tb:
+                if tb.code_context:
+                    code = tb.code_context[0].strip()
+                else:
+                    code = "No code context available"
+                msg = f"Reactive variable was initialized at {tb.filename}:{tb.lineno} with {initial!r}, but was mutated to {current!r}.\n" f"{code}"
+            else:
+                msg = f"Reactive variable was initialized with a value of {initial!r}, but was mutated to {current!r} (unable to report the location in the source code)."
+            raise ValueError(msg)
+
 
 def _create_key_callable(f: Callable[[], S]):
     try:
@@ -302,22 +399,48 @@ def _create_key_callable(f: Callable[[], S]):
 
 
 class KernelStoreFactory(KernelStore[S]):
-    def __init__(self, factory: Callable[[], S], key=None):
+    def __init__(self, factory: Callable[[], S], key=None, equals: Callable[[Any, Any], bool] = equals_extra):
         self.factory = factory
         key = key or _create_key_callable(factory)
-        super().__init__(key=key)
+        super().__init__(key=key, equals=equals)
 
     def initial_value(self) -> S:
         return self.factory()
 
 
+def mutation_detection_storage(default_value: S, key=None, equals=None) -> ValueBase[S]:
+    from solara.util import equals_pickle as default_equals
+    from ._stores import MutateDetectorStore, StoreValue, _PublicValueNotSet
+
+    kernel_store = KernelStoreValue[StoreValue[S]](
+        StoreValue[S](private=default_value, public=_PublicValueNotSet(), get_traceback=None, set_value=None, set_traceback=None),
+        key=key,
+        unwrap=lambda x: x.private,
+    )
+    return MutateDetectorStore[S](kernel_store, equals=equals or default_equals)
+
+
+def default_storage(default_value: S, key=None, equals=None) -> ValueBase[S]:
+    # in solara v2 we will also do this when mutation_detection is None
+    # and we do not run on production mode
+    if solara.settings.storage.mutation_detection is True:
+        return mutation_detection_storage(default_value, key=key, equals=equals)
+    else:
+        return KernelStoreValue[S](default_value, key=key, equals=equals or equals_extra)
+
+
+def _call_storage_factory(default_value: S, key=None, equals=None) -> ValueBase[S]:
+    factory = solara.settings.storage.get_factory()
+    return factory(default_value, key=key, equals=equals)
+
+
 class Reactive(ValueBase[S]):
     _storage: ValueBase[S]
 
-    def __init__(self, default_value: Union[S, ValueBase[S]], key=None):
+    def __init__(self, default_value: Union[S, ValueBase[S]], key=None, equals=None):
         super().__init__()
         if not isinstance(default_value, ValueBase):
-            self._storage = KernelStoreValue(default_value, key=key)
+            self._storage = _call_storage_factory(default_value, key=key, equals=equals)
         else:
             self._storage = default_value
         self.__post__init__()
@@ -505,11 +628,11 @@ def computed(
 
 
 class ReactiveField(Reactive[T]):
-    def __init__(self, field: "FieldBase"):
+    def __init__(self, field: "FieldBase", equals: Callable[[Any, Any], bool] = equals_extra):
         # super().__init__()  # type: ignore
         # We skip the Reactive constructor, because we do not need it, but we do
         # want to be an instanceof for use in use_reactive
-        ValueBase.__init__(self)
+        ValueBase.__init__(self, equals=equals)
         self._field = field
         field = field
         while not isinstance(field, ValueBase):
@@ -536,7 +659,7 @@ class ReactiveField(Reactive[T]):
             except KeyError:
                 return  # same
             old_value = self._field.get(old)
-            if not equals(new_value, old_value):
+            if not self.equals(new_value, old_value):
                 listener(new_value)
 
         return self._root.subscribe_change(on_change, scope=scope)
@@ -550,7 +673,7 @@ class ReactiveField(Reactive[T]):
             except KeyError:
                 return  # see subscribe
             old_value = self._field.get(old)
-            if not equals(new_value, old_value):
+            if not self.equals(new_value, old_value):
                 listener(new_value, old_value)
 
         return self._root.subscribe_change(on_change, scope=scope)

solara/util.py

@@ -31,6 +31,28 @@ except RuntimeError:
     has_threads = False
 
 
+from reacton.utils import equals as equals_extra
+
+
+def equals_pickle(a, b):
+    """Compare two values for equality.
+
+    Avoid false negative, e.g. when comparing dataframes, we want to compare
+    the data, not the object identity.
+
+    """
+    if equals_extra(a, b):
+        return True
+    import pickle
+
+    try:
+        if pickle.dumps(a) == pickle.dumps(b):
+            return True
+    except Exception:
+        pass
+    return False
+
+
 def github_url(file):
     rel_path = os.path.relpath(file, Path(solara.__file__).parent.parent)
     github_url = solara.github_url + f"/blob/{solara.git_branch}/" + rel_path

solara/website/components/markdown.py

@@ -1,8 +1,12 @@
 from typing import Dict, List, Union
 
 import yaml
+import markdown
+import mkdocs_pycafe
+import pymdownx.superfences
 
 import solara
+from solara.components.markdown import formatter, _no_deep_copy_emojione
 
 
 # We want to separate metadata from the markdown files before rendering them, which solara.Markdown doesn't support
@@ -27,12 +31,52 @@ def MarkdownWithMetadata(content: str, unsafe_solara_execute=True):
                 solara.Meta(property=key, content=value)
             else:
                 solara.Meta(name=key, content=value)
+
+    def make_markdown_object():
+        return markdown.Markdown(  # type: ignore
+            extensions=[
+                "pymdownx.highlight",
+                "pymdownx.superfences",
+                "pymdownx.emoji",
+                "toc",  # so we get anchors for h1 h2 etc
+                "tables",
+            ],
+            extension_configs={
+                "pymdownx.emoji": {
+                    "emoji_index": _no_deep_copy_emojione,
+                },
+                "pymdownx.superfences": {
+                    "custom_fences": [
+                        {
+                            "name": "mermaid",
+                            "class": "mermaid",
+                            "format": pymdownx.superfences.fence_div_format,
+                        },
+                        {
+                            "name": "solara",
+                            "class": "",
+                            "validator": mkdocs_pycafe.validator,
+                            "format": mkdocs_pycafe.formatter(type="solara", next_formatter=formatter(unsafe_solara_execute), inside_last_div=False),
+                        },
+                        {
+                            "name": "python",
+                            "class": "highlight",
+                            "validator": mkdocs_pycafe.validator,
+                            "format": mkdocs_pycafe.formatter(type="solara", next_formatter=formatter(unsafe_solara_execute), inside_last_div=False),
+                        },
+                    ],
+                },
+            },
+        )
+
+    md_parser = solara.use_memo(make_markdown_object, dependencies=[unsafe_solara_execute])
+
     with solara.v.Html(
         tag="div",
         style_="display: flex; flex-direction: row; justify-content: center; gap: 15px; max-width: 90%; margin: 0 auto;",
         attributes={"id": "markdown-to-navigate"},
     ):
-        solara.Markdown(content, unsafe_solara_execute=unsafe_solara_execute, style="flex-grow: 1; max-width: min(100%, 1024px);")
+        solara.Markdown(content, unsafe_solara_execute=unsafe_solara_execute, style="flex-grow: 1; max-width: min(100%, 1024px);", md_parser=md_parser)
         MarkdownNavigation(id="markdown-to-navigate").key("markdown-nav" + str(hash(content)))
 
 

solara/website/pages/changelog/changelog.md

@@ -1,5 +1,14 @@
 # Solara Changelog
 
+## Version 1.41.0
+   * Feature: Mutation detection is now available under the `SOLARA_STORAGE_MUTATION_DETECTION` environmental variable. [#595](https://github.com/widgetti/solara/pull/595).
+   * Feature: Autofocusing text inputs is now supported. [#788](https://github.com/widgetti/solara/pull/788).
+   * Feature: Custom colours are now supported for the Solara loading spinner. [#858](https://github.com/widgetti/solara/pull/858)
+   * Bug Fix: Echarts responsive size is now properly supported. [#273](https://github.com/widgetti/solara/pull/273).
+   * Bug Fix: Some version checks would prevent Solara from starting. [#904](https://github.com/widgetti/solara/pull/904).
+   * Bug Fix: Solara apps running in qt mode (`--qt`) should now always work correctly. [#856](https://github.com/widgetti/solara/pull/856).
+   * Bug Fix: Hot reloading of files outside working directory would crash app. [069a205](https://github.com/widgetti/solara/commit/069a205c88a8cbcb0b0ca23f4d56889c8ad6134a) and [#869](https://github.com/widgetti/solara/pull/869).
+
 ## Version 1.40.0
    * Feature: In Jupyter Notebook and Lab, Solara (server) now renders the [ipypopout](https://github.com/widgetti/ipypopout) window instead of Voila [#805](render ipypopout content in jupyter notebook and lab)
    * Feature: Support styling input field of [ChatInput component](https://solara.dev/documentation/components/lab/chat). [#800](https://github.com/widgetti/solara/pull/800).

solara/website/pages/documentation/api/cross_filter/cross_filter_dataframe.py

@@ -13,11 +13,10 @@ df = plotly.data.gapminder()
 @solara.component
 def Page():
     solara.provide_cross_filter()
-    with solara.VBox() as main:
-        solara.CrossFilterReport(df, classes=["py-2"])
-        solara.CrossFilterSelect(df, "country")
-        solara.CrossFilterDataFrame(df)
-    return main
+
+    solara.CrossFilterReport(df, classes=["py-2"])
+    solara.CrossFilterSelect(df, "country")
+    solara.CrossFilterDataFrame(df)
 
 
 __doc__ += apidoc(solara.CrossFilterDataFrame.f)  # type: ignore

solara/website/pages/documentation/api/cross_filter/cross_filter_report.py

@@ -12,11 +12,9 @@ df = plotly.data.gapminder()
 @solara.component
 def Page():
     solara.provide_cross_filter()
-    with solara.VBox() as main:
-        solara.CrossFilterReport(df, classes=["py-2"])
-        solara.CrossFilterSelect(df, "country")
-        solara.CrossFilterSlider(df, "gdpPercap", mode=">")
-    return main
+    solara.CrossFilterReport(df, classes=["py-2"])
+    solara.CrossFilterSelect(df, "country")
+    solara.CrossFilterSlider(df, "gdpPercap", mode=">")
 
 
 __doc__ += apidoc(solara.CrossFilterReport.f)  # type: ignore

solara/website/pages/documentation/api/cross_filter/cross_filter_select.py

@@ -12,11 +12,9 @@ df = plotly.data.tips()
 @solara.component
 def Page():
     solara.provide_cross_filter()
-    with solara.VBox() as main:
-        solara.CrossFilterReport(df, classes=["py-2"])
-        solara.CrossFilterSelect(df, "sex")
-        solara.CrossFilterSelect(df, "time")
-    return main
+    solara.CrossFilterReport(df, classes=["py-2"])
+    solara.CrossFilterSelect(df, "sex")
+    solara.CrossFilterSelect(df, "time")
 
 
 __doc__ += apidoc(solara.CrossFilterSelect.f)  # type: ignore

solara/website/pages/documentation/api/cross_filter/cross_filter_slider.py

@@ -12,11 +12,9 @@ df = plotly.data.gapminder()
 @solara.component
 def Page():
     solara.provide_cross_filter()
-    with solara.VBox() as main:
-        solara.CrossFilterReport(df, classes=["py-2"])
-        solara.CrossFilterSlider(df, "pop", mode=">")
-        solara.CrossFilterSlider(df, "gdpPercap", mode="<")
-    return main
+    solara.CrossFilterReport(df, classes=["py-2"])
+    solara.CrossFilterSlider(df, "pop", mode=">")
+    solara.CrossFilterSlider(df, "gdpPercap", mode="<")
 
 
 __doc__ += apidoc(solara.CrossFilterSlider.f)  # type: ignore

solara/website/pages/documentation/api/hooks/use_cross_filter.py

@@ -15,11 +15,9 @@ df = plotly.data.gapminder()
 @solara.component
 def Page():
     solara.provide_cross_filter()
-    with solara.VBox() as main:
-        solara.CrossFilterReport(df, classes=["py-2"])
-        solara.CrossFilterSelect(df, "continent")
-        solara.CrossFilterSlider(df, "gdpPercap", mode=">")
-    return main
+    solara.CrossFilterReport(df, classes=["py-2"])
+    solara.CrossFilterSelect(df, "continent")
+    solara.CrossFilterSlider(df, "gdpPercap", mode=">")
 
 
 __doc__ += apidoc(solara.use_cross_filter)  # type: ignore

solara/website/pages/documentation/api/hooks/use_exception.py

@@ -18,16 +18,14 @@ def Page():
     value_previous = solara.use_previous(value)
     exception, clear_exception = solara.use_exception()
     # print(exception)
-    with solara.VBox() as main:
-        if exception:
+    if exception:
 
-            def reset():
-                set_value(value_previous)
-                clear_exception()
+        def reset():
+            set_value(value_previous)
+            clear_exception()
 
-            solara.Text("Exception: " + str(exception))
-            solara.Button(label="Go to previous state", on_click=reset)
-        else:
-            solara.IntSlider(value=value, min=0, max=10, on_value=set_value, label="Pick a number, except 3")
-            UnstableComponent(value)
-    return main
+        solara.Text("Exception: " + str(exception))
+        solara.Button(label="Go to previous state", on_click=reset)
+    else:
+        solara.IntSlider(value=value, min=0, max=10, on_value=set_value, label="Pick a number, except 3")
+        UnstableComponent(value)

solara/website/pages/documentation/api/hooks/use_previous.py

@@ -20,14 +20,11 @@ title = "use_previous"
 def Page():
     value, set_value = solara.use_state(4)
     value_previous = solara.use_previous(value)
-    with solara.VBox() as main:
-        solara.IntSlider("value", value=value, on_value=set_value)
-        solara.Markdown(
-            f"""
-        **Current**:  `{value}`
+    solara.IntSlider("value", value=value, on_value=set_value)
+    solara.Markdown(
+        f"""
+    **Current**:  `{value}`
 
-        **Previous**: `{value_previous}`
+    **Previous**: `{value_previous}`
 """
-        )
-
-    return main
+    )