ex4nicegui 0.7.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

ex4nicegui/reactive/officials/date.py

@@ -1,11 +1,11 @@
 from typing import Any, Callable, List, Optional, TypeVar
 from typing_extensions import TypedDict
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
-    to_value,
 )
 from nicegui import ui
 from .base import BindableUi
@@ -18,7 +18,7 @@ _TDateValue = TypeVar(
 )
 
 
-class DateBindableUi(BindableUi[ui.date]):
+class DateBindableUi(BindableUi[ui.date], ValueElementMixin[_TDateValue]):
     def __init__(
         self,
         value: Optional[TMaybeRef[_TDateValue]] = None,
@@ -63,14 +63,7 @@ class DateBindableUi(BindableUi[ui.date]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
-
-    def bind_value(self, value: TGetterOrReadonlyRef[bool]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self

ex4nicegui/reactive/officials/dialog.py

@@ -1,15 +1,15 @@
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 from ex4nicegui.utils.signals import (
     _TMaybeRef as TMaybeRef,
     is_setter_ref,
-    to_value,
     TGetterOrReadonlyRef,
 )
 from nicegui import ui
 from .base import BindableUi
 
 
-class DialogBindableUi(BindableUi[ui.dialog]):
+class DialogBindableUi(BindableUi[ui.dialog], ValueElementMixin[bool]):
     def __init__(
         self,
         *,
@@ -36,14 +36,7 @@ class DialogBindableUi(BindableUi[ui.dialog]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
-
-    def bind_value(self, value: TGetterOrReadonlyRef[float]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self

ex4nicegui/reactive/officials/echarts.py

@@ -34,7 +34,7 @@ class EChartsBindableUi(BindableUi[echarts]):
 
         value_kws = pc.get_values_kws()
 
-        element = echarts(**value_kws).classes("grow self-stretch h-[16rem]")
+        element = echarts(**value_kws).classes("nicegui-echart")
 
         super().__init__(element)  # type: ignore
 
@@ -94,13 +94,14 @@ class EChartsBindableUi(BindableUi[echarts]):
 
     @classmethod
     def from_pyecharts(cls, chart: TMaybeRef):
-        if is_ref(chart):
+        if is_ref(chart) or callable(chart):
 
             @ref_computed
             def chart_opt():
-                if not bool(chart.value):
+                chart_value = to_value(chart)
+                if not bool(chart_value):
                     return {}
-                return PyechartsUtils._chart2opts(chart.value)
+                return PyechartsUtils._chart2opts(chart_value)
 
             return cls(chart_opt)
 
@@ -139,7 +140,7 @@ class EChartsBindableUi(BindableUi[echarts]):
         return super().bind_prop(prop, value)
 
     def bind_options(self, options: TGetterOrReadonlyRef[Dict]):
-        @self._ui_signal_on(options)
+        @self._ui_signal_on(options, deep=True)
         def _():
             ele = self.element
             ele.update_options(to_raw(to_value(options)), self.__update_setting)
@@ -228,7 +229,10 @@ class EChartsBindableUi(BindableUi[echarts]):
         return self
 
     def run_chart_method(
-        self, name: str, *args, timeout: float = 1, check_interval: float = 0.01
+        self,
+        name: str,
+        *args,
+        timeout: float = 1,
     ) -> AwaitableResponse:
         """Run a method of the JSONEditor instance.
 
@@ -240,7 +244,6 @@ class EChartsBindableUi(BindableUi[echarts]):
         :param name: name of the method (a prefix ":" indicates that the arguments are JavaScript expressions)
         :param args: arguments to pass to the method (Python objects or JavaScript expressions)
         :param timeout: timeout in seconds (default: 1 second)
-        :param check_interval: interval in seconds to check for a response (default: 0.01 seconds)
 
         :return: AwaitableResponse that can be awaited to get the result of the method call
         """
@@ -248,7 +251,6 @@ class EChartsBindableUi(BindableUi[echarts]):
             name,
             *args,
             timeout=timeout,
-            check_interval=check_interval,
         )
 
 

ex4nicegui/reactive/officials/expansion.py

@@ -1,15 +1,15 @@
 from typing import Any, Optional, Callable
 from nicegui import ui
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
-    to_value,
 )
 from .base import BindableUi
 
 
-class ExpansionBindableUi(BindableUi[ui.expansion]):
+class ExpansionBindableUi(BindableUi[ui.expansion], ValueElementMixin[bool]):
     def __init__(
         self,
         text: Optional[TMaybeRef[str]] = None,
@@ -46,18 +46,11 @@ class ExpansionBindableUi(BindableUi[ui.expansion]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self
-
     def __enter__(self):
         self.element.__enter__()
         return self

ex4nicegui/reactive/officials/icon.py

@@ -1,6 +1,5 @@
 from typing import (
     Optional,
-    cast,
 )
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
@@ -9,9 +8,6 @@ from ex4nicegui.utils.signals import (
     to_value,
 )
 from nicegui import ui
-from nicegui.elements.mixins.color_elements import (
-    TextColorElement,
-)
 from .base import BindableUi
 from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
 
@@ -44,10 +40,8 @@ class IconBindableUi(BindableUi[ui.icon], TextColorableMixin):
         return super().bind_prop(prop, value)
 
     def bind_name(self, name: TGetterOrReadonlyRef):
-        @self._ui_effect
+        @self._ui_signal_on(name)
         def _():
-            ele = cast(TextColorElement, self.element)
-            ele._props["name"] = to_value(name)
-            ele.update()
+            self.element.set_name(to_value(name))
 
         return self

ex4nicegui/reactive/officials/image.py

@@ -32,6 +32,6 @@ class ImageBindableUi(BindableUi[ui.image]):
         return super().bind_prop(prop, value)
 
     def bind_source(self, source: TGetterOrReadonlyRef[Union[str, Path]]):
-        @self._ui_effect
+        @self._ui_signal_on(source, deep=False)
         def _():
             self.element.set_source(to_value(source))

ex4nicegui/reactive/officials/input.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, List, Optional, Dict, cast
+from typing import Any, Callable, List, Optional, Dict, Union, cast
 
 
 from ex4nicegui.utils.signals import (
@@ -13,9 +13,14 @@ from nicegui import ui
 from nicegui.events import handle_event
 from .base import BindableUi, DisableableMixin
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
-class InputBindableUi(BindableUi[ui.input], DisableableMixin):
+class InputBindableUi(
+    BindableUi[ui.input],
+    DisableableMixin,
+    ValueElementMixin[str],
+):
     def __init__(
         self,
         label: Optional[TMaybeRef[str]] = None,
@@ -26,7 +31,9 @@ class InputBindableUi(BindableUi[ui.input], DisableableMixin):
         password_toggle_button: TMaybeRef[bool] = False,
         on_change: Optional[Callable[..., Any]] = None,
         autocomplete: Optional[TMaybeRef[List[str]]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[
+            Union[Callable[..., Optional[str]], Dict[str, Callable[..., bool]]]
+        ] = None,
     ) -> None:
         pc = ParameterClassifier(
             locals(),
@@ -52,23 +59,15 @@ class InputBindableUi(BindableUi[ui.input], DisableableMixin):
             self.bind_prop(key, value)  # type: ignore
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
         if prop == "password":
             return self.bind_password(value)
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef[str]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-            self.element.update()
-
-        return self
-
     def bind_password(self, password: TGetterOrReadonlyRef[bool]):
-        @self._ui_effect
+        @self._ui_signal_on(password)
         def _():
             self.element._props["type"] = "password" if to_value(password) else "text"
             self.element.update()

ex4nicegui/reactive/officials/knob.py

@@ -6,18 +6,16 @@ from typing import (
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     _TMaybeRef as TMaybeRef,
-    to_value,
     TGetterOrReadonlyRef,
 )
 from nicegui import ui
 from .base import BindableUi, DisableableMixin
 from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
 class KnobBindableUi(
-    BindableUi[ui.knob],
-    DisableableMixin,
-    TextColorableMixin,
+    BindableUi[ui.knob], DisableableMixin, TextColorableMixin, ValueElementMixin[float]
 ):
     def __init__(
         self,
@@ -62,16 +60,9 @@ class KnobBindableUi(
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
         if prop == "color":
             return self.bind_color(value)
 
         return super().bind_prop(prop, value)
-
-    def bind_value(self, value: TGetterOrReadonlyRef[float]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self

ex4nicegui/reactive/officials/label.py

@@ -3,6 +3,7 @@ from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     to_value,
+    to_raw,
     _TMaybeRef as TMaybeRef,
 )
 from nicegui import ui
@@ -17,7 +18,9 @@ class LabelBindableUi(BindableUi[ui.label], HtmlTextColorableMixin):
     ) -> None:
         pc = ParameterClassifier(locals(), maybeRefs=["text"], events=[])
 
-        element = ui.label(**pc.get_values_kws())
+        init_kws = pc.get_values_kws()
+        init_kws.update({"text": str(init_kws.get("text", ""))})
+        element = ui.label(**init_kws)
         super().__init__(element)
 
         for key, value in pc.get_bindings().items():
@@ -37,9 +40,8 @@ class LabelBindableUi(BindableUi[ui.label], HtmlTextColorableMixin):
         return super().bind_prop(prop, value)
 
     def bind_text(self, text: TGetterOrReadonlyRef):
-        @self._ui_effect
+        @self._ui_signal_on(text, deep=True)
         def _():
-            self.element.set_text(str(to_value(text)))
-            self.element.update()
+            self.element.set_text(str(to_raw(to_value(text))))
 
         return self

ex4nicegui/reactive/officials/linear_progress.py

@@ -5,15 +5,17 @@ from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
-    to_value,
 )
 from nicegui import ui
 
 from .base import BindableUi
 from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
-class LinearProgressBindableUi(BindableUi[ui.linear_progress], TextColorableMixin):
+class LinearProgressBindableUi(
+    BindableUi[ui.linear_progress], TextColorableMixin, ValueElementMixin[float]
+):
     def __init__(
         self,
         value: TMaybeRef[float] = 0.0,
@@ -47,17 +49,10 @@ class LinearProgressBindableUi(BindableUi[ui.linear_progress], TextColorableMixi
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         if prop == "color":
             return self.bind_color(value)
 
         return super().bind_prop(prop, value)
-
-    def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self

ex4nicegui/reactive/officials/number.py

@@ -7,6 +7,7 @@ from typing import (
     Union,
 )
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
@@ -22,7 +23,7 @@ def _default_vmodel_args_getter(e):
     return e.sender.value
 
 
-class NumberBindableUi(BindableUi[ui.number]):
+class NumberBindableUi(BindableUi[ui.number], ValueElementMixin[Union[float, int]]):
     def __init__(
         self,
         label: Optional[TMaybeRef[str]] = None,
@@ -37,7 +38,9 @@ class NumberBindableUi(BindableUi[ui.number]):
         suffix: Optional[TMaybeRef[str]] = None,
         format: Optional[TMaybeRef[str]] = None,
         on_change: Optional[Callable[..., Any]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[
+            Union[Callable[..., Optional[str]], Dict[str, Callable[..., bool]]]
+        ] = None,
     ) -> None:
         pc = ParameterClassifier(
             locals(),
@@ -71,23 +74,16 @@ class NumberBindableUi(BindableUi[ui.number]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         if prop == "precision":
             return self._bind_precision(value)
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef[float]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self
-
     def _bind_precision(self, precision: TGetterOrReadonlyRef[int]):
-        @self._ui_signal_on(precision, onchanges=True)
+        @self._ui_signal_on(precision)
         def _():
             self.element.precision = to_value(precision)
             self.element.sanitize()

ex4nicegui/reactive/officials/radio.py

@@ -4,7 +4,6 @@ from typing import (
     List,
     Optional,
     TypeVar,
-    cast,
     Dict,
     Union,
 )
@@ -15,13 +14,13 @@ from ex4nicegui.utils.signals import (
     to_value,
 )
 from nicegui import ui
-from nicegui.elements.mixins.value_element import ValueElement
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 from .base import BindableUi
 
 T = TypeVar("T")
 
 
-class RadioBindableUi(BindableUi[ui.radio]):
+class RadioBindableUi(BindableUi[ui.radio], ValueElementMixin[Any]):
     def __init__(
         self,
         options: Union[TMaybeRef[List], TMaybeRef[Dict]],
@@ -52,8 +51,8 @@ class RadioBindableUi(BindableUi[ui.radio]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         if prop == "options":
             return self.bind_options(value)
@@ -61,15 +60,8 @@ class RadioBindableUi(BindableUi[ui.radio]):
         return super().bind_prop(prop, value)
 
     def bind_options(self, options: TGetterOrReadonlyRef):
-        @self._ui_effect
+        @self._ui_signal_on(options, deep=True)
         def _():
             self.element.set_options(to_value(options))
 
         return self
-
-    def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            cast(ValueElement, self.element).set_value(to_value(value))
-
-        return self

ex4nicegui/reactive/officials/row.py

@@ -1,17 +1,25 @@
 from typing import (
     Any,
+    Literal,
+    Optional,
 )
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
-from ex4nicegui.utils.signals import (
-    _TMaybeRef as TMaybeRef,
-)
+from ex4nicegui.reactive.mixins.flexLayout import FlexAlignItemsMixin, FlexWrapMixin
+from ex4nicegui.utils.signals import TMaybeRef
 from nicegui import ui
 from .base import BindableUi
 
 
-class RowBindableUi(BindableUi[ui.row]):
-    def __init__(self, *, wrap: TMaybeRef[bool] = True) -> None:
-        pc = ParameterClassifier(locals(), maybeRefs=["wrap"], events=[])
+class RowBindableUi(BindableUi[ui.row], FlexAlignItemsMixin, FlexWrapMixin):
+    def __init__(
+        self,
+        *,
+        wrap: TMaybeRef[bool] = True,
+        align_items: Optional[
+            TMaybeRef[Literal["start", "end", "center", "baseline", "stretch"]]
+        ] = None,
+    ) -> None:
+        pc = ParameterClassifier(locals(), maybeRefs=["wrap", "align_items"], events=[])
         element = ui.row(**pc.get_values_kws())
 
         super().__init__(element)
@@ -19,14 +27,13 @@ class RowBindableUi(BindableUi[ui.row]):
             self.bind_prop(key, value)  # type: ignore
 
     def bind_prop(self, prop: str, value: TMaybeRef):
-        if prop == "wrap":
-            return self.bind_wrap(value)
+        if FlexAlignItemsMixin._bind_specified_props(self, prop, value):
+            return self
+        if FlexWrapMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
 
-    def bind_wrap(self, value: TMaybeRef):
-        self.bind_classes({"wrap": value})
-
     def __enter__(self):
         self.element.__enter__()
         return self

ex4nicegui/reactive/officials/select.py

@@ -84,14 +84,14 @@ class SelectBindableUi(BindableUi[ui.select]):
         return super().bind_prop(prop, value)
 
     def bind_options(self, options: TGetterOrReadonlyRef):
-        @self._ui_effect()
+        @self._ui_signal_on(options, deep=True)
         def _():
             self.element.set_options(to_value(options))
 
         return self
 
     def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect()
+        @self._ui_signal_on(value, deep=True)
         def _():
             cast(ValueElement, self.element).set_value(to_raw(to_value(value)) or None)
 

ex4nicegui/reactive/officials/slider.py

@@ -16,14 +16,14 @@ from ex4nicegui.utils.signals import (
 from nicegui import ui
 from nicegui.events import handle_event
 from .base import BindableUi, DisableableMixin
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
 _TSliderValue = TypeVar("_TSliderValue", float, int, None)
 
 
 class SliderBindableUi(
-    BindableUi[ui.slider],
-    DisableableMixin,
+    BindableUi[ui.slider], DisableableMixin, ValueElementMixin[_TSliderValue]
 ):
     def __init__(
         self,
@@ -59,19 +59,11 @@ class SliderBindableUi(
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef[float]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-            self.element.update()
-
-        return self
-
 
 class LazySliderBindableUi(SliderBindableUi):
     def __init__(

ex4nicegui/reactive/officials/switch.py

@@ -8,15 +8,16 @@ from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
-    to_value,
 )
 from nicegui import ui
 from .base import BindableUi
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
+
 
 T = TypeVar("T")
 
 
-class SwitchBindableUi(BindableUi[ui.switch]):
+class SwitchBindableUi(BindableUi[ui.switch], ValueElementMixin[bool]):
     def __init__(
         self,
         text: TMaybeRef[str] = "",
@@ -35,7 +36,6 @@ class SwitchBindableUi(BindableUi[ui.switch]):
         )
 
         value_kws = pc.get_values_kws()
-        value_kws.update({"value": 0 if value is None else value})
 
         element = ui.switch(**value_kws)
         super().__init__(element)  # type: ignore
@@ -48,14 +48,6 @@ class SwitchBindableUi(BindableUi[ui.switch]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
-
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
         return super().bind_prop(prop, value)
-
-    def bind_value(self, value: TGetterOrReadonlyRef[bool]):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self

ex4nicegui/reactive/officials/tab_panels.py

@@ -10,9 +10,10 @@ from ex4nicegui.utils.signals import (
 from ex4nicegui.utils.scheduler import next_tick
 from nicegui import ui, background_tasks, core
 from .base import BindableUi
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
-class TabPanelsBindableUi(BindableUi[ui.tab_panels]):
+class TabPanelsBindableUi(BindableUi[ui.tab_panels], ValueElementMixin[bool]):
     def __init__(
         self,
         value: Optional[TMaybeRef[str]] = None,
@@ -50,16 +51,11 @@ class TabPanelsBindableUi(BindableUi[ui.tab_panels]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
 
 class lazy_tab_panel(ui.tab_panel):
     def __init__(self, name: str) -> None: