solara-ui 1.42.0__tar.gz → 1.44.0__tar.gz

{solara_ui-1.42.0 → solara_ui-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solara-ui
-Version: 1.42.0
+Version: 1.44.0
 Dynamic: Summary
 Project-URL: Home, https://www.github.com/widgetti/solara
 Project-URL: Documentation, https://solara.dev
@@ -31,7 +31,7 @@ Requires-Dist: humanize
 Requires-Dist: ipyvue>=1.9.0
 Requires-Dist: ipyvuetify>=1.6.10
 Requires-Dist: ipywidgets>=7.7
-Requires-Dist: reacton>=1.7.1
+Requires-Dist: reacton>=1.9
 Requires-Dist: requests
 Provides-Extra: all
 Requires-Dist: cachetools; extra == 'all'

{solara_ui-1.42.0 → solara_ui-1.44.0}/pyproject.toml

@@ -14,7 +14,7 @@ packages = [
     { include = "solara" }
 ]
 dependencies = [
-    "reacton>=1.7.1",
+    "reacton>=1.9",
     "ipywidgets>=7.7",
     "ipyvuetify>=1.6.10",
     "ipyvue>=1.9.0",
@@ -85,6 +85,7 @@ extra = [
 fix = false
 line-length = 160
 lint.ignore = ["E402"]
+target-version = "py38"
 
 [tool.black]
 line-length = 160

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/__init__.py

@@ -1,6 +1,6 @@
 """Build webapps using IPywidgets"""
 
-__version__ = "1.42.0"
+__version__ = "1.44.0"
 github_url = "https://github.com/widgetti/solara"
 git_branch = "master"
 

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/__main__.py

@@ -21,6 +21,8 @@ import solara.server.threaded
 
 from .server import telemetry
 
+print_mutex = threading.Lock()
+
 try:
     from solara_enterprise.ssg import ssg_crawl
 except ImportError:
@@ -75,13 +77,15 @@ def _check_version():
     import requests
 
     try:
-        response = requests.get("https://pypi.org/pypi/solara/json")
+        response = requests.get("https://pypi.org/pypi/solara/json", timeout=0.5)
         latest_version = response.json()["info"]["version"]
     except:  # noqa: E722
+        # in case of a firewall, or timeout, we just abort
         return
     if latest_version != solara.__version__:
-        print(f"New version of Solara available: {latest_version}. You have {solara.__version__}. Please upgrade using:")  # noqa: T201
-        print(f'\t$ pip install "solara=={latest_version}"')  # noqa: T201
+        with print_mutex:
+            print(f"New version of Solara available: {latest_version}. You have {solara.__version__}. Please upgrade using:")  # noqa: T201
+            print(f'\t$ pip install "solara=={latest_version}"')  # noqa: T201
 
 
 def find_all_packages_paths():
@@ -152,7 +156,7 @@ if "SOLARA_MODE" in os.environ:
     "--restart-dir",
     "restart_dirs",
     multiple=True,
-    help="Set restart directories explicitly, instead of using the current working" " directory.",
+    help="Set restart directories explicitly, instead of using the current working directory.",
     type=click.Path(exists=True),
 )
 @click.option(
@@ -168,7 +172,7 @@ if "SOLARA_MODE" in os.environ:
     "--workers",
     default=None,
     type=int,
-    help="Number of worker processes. Defaults to the $WEB_CONCURRENCY environment" " variable if available, or 1. Not valid with --auto-restart/-a.",
+    help="Number of worker processes. Defaults to the $WEB_CONCURRENCY environment variable if available, or 1. Not valid with --auto-restart/-a.",
 )
 @click.option(
     "--env-file",
@@ -306,7 +310,7 @@ def run(
         print("solara: --reload is deprecated, use --auto-restart/-a instead", file=sys.stderr)  # noqa: T201
         auto_restart = reload
     if check_version:
-        _check_version()
+        threading.Thread(target=_check_version, daemon=True).run()
 
     # uvicorn calls it reload, we call it auto restart
     reload = auto_restart
@@ -390,7 +394,8 @@ def run(
     if open and not qt:
         threading.Thread(target=open_browser, daemon=True).start()
 
-    rich.print(f"Solara server is starting at {url}")
+    with print_mutex:
+        rich.print(f"Solara server is starting at {url}")
 
     if log_level is not None:
         LOGGING_CONFIG["loggers"]["solara"]["level"] = log_level.upper()

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/_stores.py

@@ -1,27 +1,37 @@
 import copy
 import dataclasses
 import inspect
-from typing import Callable, ContextManager, Generic, Optional, Union, cast
+import sys
+import threading
+from typing import Callable, ContextManager, Generic, Optional, Union, cast, Any
 import warnings
-from .toestand import ValueBase, KernelStore, S, _find_outside_solara_frame
+
+
+from .toestand import ValueBase, S, _find_outside_solara_frame, _DEBUG
+
 import solara.util
+import solara.settings
 
 
 class _PublicValueNotSet:
     pass
 
 
+class _SetValueNotSet:
+    pass
+
+
 @dataclasses.dataclass
 class StoreValue(Generic[S]):
     private: S  # the internal private value, should never be mutated
     public: Union[S, _PublicValueNotSet]  # this is the value that is exposed in .get(), it is a deep copy of private
     get_traceback: Optional[inspect.Traceback]
-    set_value: Optional[S]  # the value that was set using .set(..), we deepcopy this to set private
+    set_value: Union[S, _SetValueNotSet]  # the value that was set using .set(..), we deepcopy this to set private
     set_traceback: Optional[inspect.Traceback]
 
 
 class MutateDetectorStore(ValueBase[S]):
-    def __init__(self, store: KernelStore[StoreValue[S]], equals=solara.util.equals_extra):
+    def __init__(self, store: ValueBase[StoreValue[S]], equals=solara.util.equals_extra):
         self._storage = store
         self._enabled = True
         super().__init__(equals=equals)
@@ -77,9 +87,9 @@ class MutateDetectorStore(ValueBase[S]):
                     code = tb.code_context[0]
                 else:
                     code = "<No code context available>"
-                msg += f"The last value was read in the following code:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                msg += f"The last value was read in the following code:\n{tb.filename}:{tb.lineno}\n{code}"
             raise ValueError(msg)
-        elif store_value.set_value is not None and not self.equals(store_value.set_value, store_value.private):
+        elif not isinstance(store_value.set_value, _SetValueNotSet) and not self.equals(store_value.set_value, store_value.private):
             tb = store_value.set_traceback
             msg = f"""Reactive variable was set with a value of {store_value.private!r}, but was later mutated mutated to {store_value.set_value!r}.
 
@@ -110,7 +120,7 @@ Good (if you want to keep mutating your own list):
                     code = tb.code_context[0]
                 else:
                     code = "<No code context available>"
-                msg += "The last time the value was set was at:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                msg += f"The last time the value was set was at:\n{tb.filename}:{tb.lineno}\n{code}"
             raise ValueError(msg)
 
     def _ensure_public_exists(self):
@@ -154,18 +164,18 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
                     code = tb.code_context[0]
                 else:
                     code = "<No code context available>"
-                warn += "This warning was triggered from:\n" f"{tb.filename}:{tb.lineno}\n" f"{code}"
+                warn += f"This warning was triggered from:\n{tb.filename}:{tb.lineno}\n{code}"
             warnings.warn(warn)
             self._enabled = False
 
     def subscribe(self, listener: Callable[[S], None], scope: Optional[ContextManager] = None):
         def listener_wrapper(new: StoreValue[S], previous: StoreValue[S]):
             self._ensure_public_exists()
-            assert new.public is not None
-            assert previous.public is not None
-            previous_value = previous.set_value if previous.set_value is not None else previous.private
+            assert not isinstance(new.public, _PublicValueNotSet)
+            assert not isinstance(previous.public, _PublicValueNotSet)
+            previous_value = previous.set_value if not isinstance(previous.set_value, _SetValueNotSet) else previous.private
             new_value = new.set_value
-            assert new_value is not None
+            assert not isinstance(new_value, _SetValueNotSet)
             if not self.equals(new_value, previous_value):
                 listener(new_value)
 
@@ -174,12 +184,114 @@ reactive_df = solara.reactive(df, equals=solara.util.equals_pickle)
     def subscribe_change(self, listener: Callable[[S, S], None], scope: Optional[ContextManager] = None):
         def listener_wrapper(new: StoreValue[S], previous: StoreValue[S]):
             self._ensure_public_exists()
-            assert new.public is not None
-            assert previous.public is not None
-            previous_value = previous.set_value if previous.set_value is not None else previous.private
+            assert not isinstance(new.public, _PublicValueNotSet)
+            assert not isinstance(previous.public, _PublicValueNotSet)
+            previous_value = previous.set_value if not isinstance(previous.set_value, _SetValueNotSet) else previous.private
             new_value = new.set_value
-            assert new_value is not None
+            assert not isinstance(new_value, _SetValueNotSet)
             if not self.equals(new_value, previous_value):
                 listener(new_value, previous_value)
 
         return self._storage.subscribe_change(listener_wrapper, scope=scope)
+
+
+class SharedStore(ValueBase[S]):
+    """Stores a single value, not kernel scoped."""
+
+    _traceback: Optional[inspect.Traceback]
+    _original_ref: Optional[S]
+    _original_ref_copy: Optional[S]
+
+    def __init__(self, value: S, equals: Callable[[Any, Any], bool] = solara.util.equals_extra, unwrap=lambda x: x):
+        # since a set can trigger events, which can trigger new updates, we need a recursive lock
+        self._lock = threading.RLock()
+        self.local = threading.local()
+        self.equals = equals
+
+        self._value = value
+        self._original_ref = None
+        self._original_ref_copy = None
+        self._unwrap = unwrap
+        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._original_ref = value
+            self._original_ref_copy = copy.deepcopy(self._original_ref)
+            if not self.equals(self._unwrap(self._original_ref), self._unwrap(self._original_ref_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 += f"This warning was triggered from:\n{tb.filename}:{tb.lineno}\n{code}"
+                warnings.warn(msg)
+                self._mutation_detection = False
+        super().__init__(equals=equals)
+
+    def _check_mutation(self):
+        if not self._mutation_detection:
+            return
+        current = self._unwrap(self._original_ref)
+        initial = self._unwrap(self._original_ref_copy)
+        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{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)
+
+    @property
+    def lock(self):
+        return self._lock
+
+    def peek(self):
+        self._check_mutation()
+        return self._value
+
+    def get(self):
+        self._check_mutation()
+        return self._value
+
+    def clear(self):
+        pass
+
+    def _get_scope_key(self):
+        return "GLOBAL"
+
+    def set(self, value: S):
+        self._check_mutation()
+        old = self.get()
+        if self.equals(old, value):
+            return
+        self._value = value
+
+        if _DEBUG:
+            import traceback
+
+            traceback.print_stack(limit=17, file=sys.stdout)
+
+            print("change old", old)  # noqa
+            print("change new", value)  # noqa
+
+        self.fire(value, old)

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/cache.py

@@ -1,3 +1,4 @@
+from collections.abc import Hashable
 import hashlib
 import inspect
 import logging
@@ -50,6 +51,7 @@ if has_cachetools:
     class Memory(cachetools.LRUCache):
         def __init__(self, max_items=solara.settings.cache.memory_max_items):
             super().__init__(maxsize=max_items)
+
 else:
 
     class Memory(dict):  # type: ignore
@@ -64,7 +66,7 @@ def _default_key(*args, **kwargs):
 
 
 class MemoizedFunction(Generic[P, R]):
-    def __init__(self, function: Callable[P, R], key: Callable[P, R], storage: Optional[Storage], allow_nonlocals=False):
+    def __init__(self, function: Callable[P, R], key: Callable[P, Hashable], storage: Optional[Storage], allow_nonlocals=False):
         self.function = function
         f: Callable = self.function
         if not allow_nonlocals:
@@ -170,7 +172,7 @@ def memoize(
 @overload
 def memoize(
     function: None = None,
-    key: Callable[P, R] = ...,
+    key: Callable[P, Hashable] = ...,
     storage: Optional[Storage] = None,
     allow_nonlocals=False,
 ) -> Callable[[Callable[P, R]], MemoizedFunction[P, R]]: ...
@@ -187,7 +189,7 @@ def memoize(
 
 def memoize(
     function: Union[None, Callable[P, R]] = None,
-    key: Union[None, Callable[P, R]] = None,
+    key: Union[None, Callable[P, Hashable]] = None,
     storage: Optional[Storage] = None,
     allow_nonlocals: bool = False,
 ) -> Union[Callable[[Callable[P, R]], MemoizedFunction[P, R]], MemoizedFunction[P, R]]:
@@ -249,7 +251,7 @@ def memoize(
     def wrapper(func: Callable[P, R]) -> MemoizedFunction[P, R]:
         return MemoizedFunction[P, R](
             func,
-            cast(Callable[P, R], key or _default_key),
+            cast(Callable[P, Hashable], key or _default_key),
             storage,
             allow_nonlocals,
         )

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/checks.py

@@ -164,7 +164,7 @@ def get_server_python_executable(silent: bool = False):
         else:
             python = pythons[0]
             if not silent:
-                warnings.warn("Found multiple find servers:\n%s\n" "We are assuming the server is running under Python executable: %s" % (info, python))
+                warnings.warn(f"Found multiple find servers:\n{info}\nWe are assuming the server is running under Python executable: {python}")
     else:
         python = pythons[0]
     return python

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/components/__init__.py

@@ -57,4 +57,21 @@ from .progress import ProgressLinear  # noqa: F401 F403
 from .component_vue import _component_vue, component_vue  # noqa: F401 F403
 import reacton.core
 
-reacton.core._default_container = Column  # noqa: F405
+try:
+    from reacton import Fragment as Fragment  # type: ignore
+except ImportError:
+    pass
+
+import logging
+from ..settings import main
+
+_container = None
+
+if main.default_container in globals():
+    _container = globals()[main.default_container]
+else:
+    logger = logging.getLogger("solara.components")
+    logger.warning(f"Default container {main.default_container} not found in solara.components. Defaulting to Column.")
+
+# TODO: When Solara 2.0 releases Column should be replaced with Fragment
+reacton.core._default_container = _container or Column  # noqa: F405

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/components/datatable.py

@@ -10,14 +10,14 @@ import solara
 import solara.hooks.dataframe
 import solara.lab
 import traitlets
-from solara.lab.hooks.dataframe import use_df_column_names
+from solara.lab.hooks.dataframe import use_df_column_names, df_row_names
 from solara.lab.utils.dataframe import df_len, df_records, df_slice
 
 from .. import CellAction, ColumnAction
 
 
 def _ensure_dict(d):
-    if dataclasses.is_dataclass(d):
+    if dataclasses.is_dataclass(d) and not isinstance(d, type):  # is_dataclass also returns True for dataclass type, rather than instance
         return dataclasses.asdict(d)
     return d
 
@@ -100,12 +100,12 @@ def DataTable(
     i2 = min(total_length, (page + 1) * items_per_page)
 
     columns = use_df_column_names(df)
-
+    rows = df_row_names(df)
     items = []
     dfs = df_slice(df, i1, i2)
     records = df_records(dfs)
     for i in range(i2 - i1):
-        item = {"__row__": i + i1}  # special key for the row number
+        item = {"__row__": format(dfs, columns, i + 1, rows[i + i1])}  # special key for the row number
         for column in columns:
             item[column] = format(dfs, column, i + i1, records[i][column])
         items.append(item)

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/components/input.py

@@ -373,6 +373,10 @@ def _use_input_type(
         error_message = str(e.args[0])
 
     def sync_back_input_value():
+        # Make sure we update string_value when the effect is rerun,
+        # Since the parsing & stringigying functions might have changed
+        set_string_value(stringify(reactive_value.value) if reactive_value.value is not None else None)
+
         def on_external_value_change(new_value: Optional[T]):
             new_string_value = stringify(new_value)
             try:
@@ -386,7 +390,7 @@ def _use_input_type(
 
         return reactive_value.subscribe(on_external_value_change)
 
-    solara.use_effect(sync_back_input_value, [reactive_value])
+    solara.use_effect(sync_back_input_value, [reactive_value, parse, stringify])
 
     return string_value, error_message, set_string_value
 

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/components/markdown.py

@@ -1,11 +1,10 @@
-import functools
 import hashlib
 import html
 import logging
 import textwrap
 import traceback
 import warnings
-from typing import Any, Dict, List, Optional, Union, cast
+from typing import Any, Callable, Dict, List, Optional, Union, cast
 import typing
 
 import ipyvuetify as v
@@ -18,6 +17,7 @@ try:
     has_pymdownx = True
 except ModuleNotFoundError:
     has_pymdownx = False
+import reacton.core
 
 import solara
 import solara.components.applayout
@@ -55,7 +55,7 @@ def ExceptionGuard(children=[]):
             solara.Column(children=children)
 
 
-def _run_solara(code):
+def _run_solara(code, cleanups):
     ast = compile(code, "markdown", "exec")
     local_scope: Dict[Any, Any] = {}
     exec(ast, local_scope)
@@ -68,6 +68,13 @@ def _run_solara(code):
     else:
         raise NameError("No Page or app defined")
     box = v.Html(tag="div")
+
+    rc: reacton.core.RenderContext
+
+    def cleanup():
+        rc.close()
+
+    cleanups.append(cleanup)
     box, rc = solara.render(cast(solara.Element, app), container=box)  # type: ignore
     widget_id = box._model_id
     return (
@@ -236,9 +243,8 @@ module.exports = {
     return template
 
 
-def _highlight(src, language, unsafe_solara_execute, *args, **kwargs):
+def _highlight(src, language, class_name=None, options=None, md=None, unsafe_solara_execute=False, cleanups=None, **kwargs):
     """Highlight a block of code"""
-
     if not has_pygments:
         warnings.warn("Pygments is not installed, code highlighting will not work, use pip install pygments to install it.")
         src_safe = html.escape(src)
@@ -255,7 +261,7 @@ def _highlight(src, language, unsafe_solara_execute, *args, **kwargs):
 
     if run_src_with_solara:
         if unsafe_solara_execute:
-            html_widget = _run_solara(src)
+            html_widget = _run_solara(src, cleanups)
             return src_html + html_widget
         else:
             return src_html + html_no_execute_enabled
@@ -263,8 +269,17 @@ def _highlight(src, language, unsafe_solara_execute, *args, **kwargs):
         return src_html
 
 
-def formatter(unsafe_solara_execute: bool):
-    return functools.partial(_highlight, unsafe_solara_execute=unsafe_solara_execute)
+def formatter(unsafe_solara_execute: bool, cleanups: List[Callable[[], None]]):
+    def wrapper(*args, **kwargs):
+        try:
+            kwargs["unsafe_solara_execute"] = unsafe_solara_execute
+            kwargs["cleanups"] = cleanups
+            return _highlight(*args, **kwargs)
+        except Exception as e:
+            logger.exception("Error while highlighting code")
+            raise e
+
+    return wrapper
 
 
 @solara.component
@@ -276,8 +291,10 @@ def MarkdownIt(md_text: str, highlight: List[int] = [], unsafe_solara_execute: b
     from mdit_py_plugins.footnote import footnote_plugin  # noqa: F401
     from mdit_py_plugins.front_matter import front_matter_plugin  # noqa: F401
 
+    cleanups = solara.use_ref(cast(List[Callable[[], None]], []))
+
     def highlight_code(code, name, attrs):
-        return _highlight(code, name, unsafe_solara_execute, attrs)
+        return _highlight(cleanups.current, code, name, unsafe_solara_execute, attrs)
 
     md = MarkdownItMod(
         "js-default",
@@ -290,6 +307,15 @@ def MarkdownIt(md_text: str, highlight: List[int] = [], unsafe_solara_execute: b
     md = md.use(container.container_plugin, name="note")
     html = md.render(md_text)
     hash = hashlib.sha256((html + str(unsafe_solara_execute) + repr(highlight)).encode("utf-8")).hexdigest()
+
+    def cleanup_wrapper():
+        def cleanup():
+            for cleanup in cleanups.current:
+                cleanup()
+
+        return cleanup
+
+    solara.use_effect(cleanup_wrapper)
     return v.VuetifyTemplate.element(template=_markdown_template(html)).key(hash)
 
 
@@ -349,6 +375,7 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
 
     md_text = textwrap.dedent(md_text)
     style = solara.util._flatten_style(style)
+    cleanups = solara.use_ref(cast(List[Callable[[], None]], []))
 
     def make_markdown_object():
         if md_parser is not None:
@@ -377,7 +404,7 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
                             {
                                 "name": "solara",
                                 "class": "",
-                                "format": formatter(unsafe_solara_execute),
+                                "format": formatter(unsafe_solara_execute, cleanups=cleanups.current),
                             },
                         ],
                     },
@@ -399,6 +426,15 @@ def Markdown(md_text: str, unsafe_solara_execute=False, style: Union[str, Dict,
         assert md_self is not None
         md_parser = md_self
     html = md_parser.convert(md_text)
+
+    def cleanup_wrapper():
+        def cleanup():
+            for cleanup in cleanups.current:
+                cleanup()
+
+        return cleanup
+
+    solara.use_effect(cleanup_wrapper, [])
     # if we update the template value, the whole vue tree will rerender (ipvue/ipyvuetify issue)
     # however, using the hash we simply generate a new widget each time
     hash = hashlib.sha256((html + str(unsafe_solara_execute)).encode("utf-8")).hexdigest()

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/components/select.py

@@ -174,7 +174,7 @@ def SelectMultiple(
             items=all_values,
             label=label,
             multiple=True,
-            dense=False,
+            dense=dense,
             disabled=disabled,
             class_=class_,
             style_=style_flat,

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/components/style.py

@@ -101,5 +101,5 @@ module.exports = {
 {css_content}
 </style>
     """
-    # using .key avoids re-using the template, which causes a flicker (due to ipyvue)
+    # using .key avoids reusing the template, which causes a flicker (due to ipyvue)
     return v.VuetifyTemplate.element(template=template).key(key)

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/hooks/use_reactive.py

@@ -1,6 +1,7 @@
 from typing import Any, Callable, Optional, TypeVar, Union
 
 import solara
+import solara.settings
 
 T = TypeVar("T")
 
@@ -105,7 +106,21 @@ def use_reactive(
 
     def create():
         if not isinstance(value, solara.Reactive):
-            return solara.reactive(value)
+            from solara._stores import SharedStore, MutateDetectorStore, StoreValue, _PublicValueNotSet, _SetValueNotSet
+            from solara.toestand import ValueBase
+
+            store: ValueBase[T]
+
+            if solara.settings.storage.mutation_detection is True:
+                shared_store = SharedStore[StoreValue[T]](
+                    StoreValue[T](private=value, public=_PublicValueNotSet(), get_traceback=None, set_value=_SetValueNotSet(), set_traceback=None),
+                    unwrap=lambda x: x.private,
+                )
+                store = MutateDetectorStore[T](shared_store, equals=equals)
+            else:
+                store = SharedStore(value, equals=equals)
+
+            return solara.Reactive(store)
 
     reactive_value = solara.use_memo(create, dependencies=[])
     if isinstance(value, solara.Reactive):

{solara_ui-1.42.0 → solara_ui-1.44.0}/solara/lab/components/__init__.py

@@ -1,6 +1,7 @@
 from .chat import ChatBox, ChatInput, ChatMessage  # noqa: F401
 from .confirmation_dialog import ConfirmationDialog  # noqa: F401
 from .input_date import InputDate, InputDateRange  # noqa: F401
+from .input_time import InputTime as InputTime
 from .menu import ClickMenu, ContextMenu, Menu  # noqa: F401 F403
 from .tabs import Tab, Tabs  # noqa: F401
 from .theming import ThemeToggle, theme, use_dark_effective  # noqa: F401