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

ex4nicegui/reactive/officials/knob.py

@@ -11,11 +11,13 @@ from ex4nicegui.utils.signals import (
 )
 from nicegui import ui
 from .base import BindableUi, DisableableMixin
+from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
 
 
 class KnobBindableUi(
     BindableUi[ui.knob],
     DisableableMixin,
+    TextColorableMixin,
 ):
     def __init__(
         self,
@@ -59,15 +61,17 @@ class KnobBindableUi(
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
+        if prop == "color":
+            return self.bind_color(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef[float]):
+    def bind_value(self, value: TGetterOrReadonlyRef[float]):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
 
         return self

ex4nicegui/reactive/officials/label.py

@@ -7,9 +7,10 @@ from ex4nicegui.utils.signals import (
 )
 from nicegui import ui
 from .base import BindableUi
+from ex4nicegui.reactive.mixins.textColor import HtmlTextColorableMixin
 
 
-class LabelBindableUi(BindableUi[ui.label]):
+class LabelBindableUi(BindableUi[ui.label], HtmlTextColorableMixin):
     def __init__(
         self,
         text: TMaybeRef[Any] = "",
@@ -26,27 +27,19 @@ class LabelBindableUi(BindableUi[ui.label]):
     def text(self):
         return self.element.text
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "text":
-            return self.bind_text(ref_ui)
+            return self.bind_text(value)
 
         if prop == "color":
-            return self.bind_color(ref_ui)
+            return self.bind_color(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_color(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_text(self, text: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
-            ele = self.element
-            color = to_value(ref_ui)
-            ele._style["color"] = color
-            ele.update()
-
-    def bind_text(self, ref_ui: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            self.element.set_text(str(to_value(ref_ui)))
+            self.element.set_text(str(to_value(text)))
             self.element.update()
 
         return self

ex4nicegui/reactive/officials/linear_progress.py

@@ -10,10 +10,10 @@ from ex4nicegui.utils.signals import (
 from nicegui import ui
 
 from .base import BindableUi
-from ex4nicegui.reactive.services import color_service
+from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
 
 
-class LinearProgressBindableUi(BindableUi[ui.linear_progress]):
+class LinearProgressBindableUi(BindableUi[ui.linear_progress], TextColorableMixin):
     def __init__(
         self,
         value: TMaybeRef[float] = 0.0,
@@ -46,21 +46,18 @@ class LinearProgressBindableUi(BindableUi[ui.linear_progress]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
         if prop == "color":
-            return self.bind_color(ref_ui)
+            return self.bind_color(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_color(self, ref_ui: TGetterOrReadonlyRef):
-        return color_service.bind_color(self, ref_ui)
-
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_value(self, value: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
 
         return self

ex4nicegui/reactive/officials/number.py

@@ -70,26 +70,26 @@ class NumberBindableUi(BindableUi[ui.number]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
         if prop == "precision":
-            return self._bind_precision(ref_ui)
+            return self._bind_precision(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef[float]):
+    def bind_value(self, value: TGetterOrReadonlyRef[float]):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
 
         return self
 
-    def _bind_precision(self, ref_ui: TGetterOrReadonlyRef[int]):
-        @self._ui_signal_on(ref_ui, onchanges=True)
+    def _bind_precision(self, precision: TGetterOrReadonlyRef[int]):
+        @self._ui_signal_on(precision, onchanges=True)
         def _():
-            self.element.precision = to_value(ref_ui)
+            self.element.precision = to_value(precision)
             self.element.sanitize()
 
         return self

ex4nicegui/reactive/officials/radio.py

@@ -51,25 +51,25 @@ class RadioBindableUi(BindableUi[ui.radio]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
         if prop == "options":
-            return self.bind_options(ref_ui)
+            return self.bind_options(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_options(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_options(self, options: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
-            self.element.set_options(to_value(ref_ui))
+            self.element.set_options(to_value(options))
 
         return self
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_value(self, value: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
-            cast(ValueElement, self.element).set_value(to_value(ref_ui))
+            cast(ValueElement, self.element).set_value(to_value(value))
 
         return self

ex4nicegui/reactive/officials/row.py

@@ -18,14 +18,14 @@ class RowBindableUi(BindableUi[ui.row]):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
-    def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+    def bind_prop(self, prop: str, value: TMaybeRef):
         if prop == "wrap":
-            return self.bind_wrap(ref_ui)
+            return self.bind_wrap(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_wrap(self, ref_ui: TMaybeRef):
-        self.bind_classes({"wrap": ref_ui})
+    def bind_wrap(self, value: TMaybeRef):
+        self.bind_classes({"wrap": value})
 
     def __enter__(self):
         self.element.__enter__()

ex4nicegui/reactive/officials/select.py

@@ -13,6 +13,7 @@ from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
     to_value,
+    to_raw,
 )
 from nicegui import ui
 from nicegui.elements.mixins.value_element import ValueElement
@@ -73,25 +74,25 @@ class SelectBindableUi(BindableUi[ui.select]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
         if prop == "options":
-            return self.bind_options(ref_ui)
+            return self.bind_options(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_options(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_options(self, options: TGetterOrReadonlyRef):
         @self._ui_effect()
         def _():
-            self.element.set_options(to_value(ref_ui))
+            self.element.set_options(to_value(options))
 
         return self
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_value(self, value: TGetterOrReadonlyRef):
         @self._ui_effect()
         def _():
-            cast(ValueElement, self.element).set_value(to_value(ref_ui) or None)
+            cast(ValueElement, self.element).set_value(to_raw(to_value(value)) or None)
 
         return self

ex4nicegui/reactive/officials/slider.py

@@ -30,7 +30,7 @@ class SliderBindableUi(
         min: TMaybeRef[_TSliderValue],
         max: TMaybeRef[_TSliderValue],
         step: TMaybeRef[_TSliderValue] = 1.0,
-        value: TMaybeRef[_TSliderValue] = None,
+        value: Optional[TMaybeRef[_TSliderValue]] = None,
         on_change: Optional[Callable[..., Any]] = None,
     ) -> None:
         pc = ParameterClassifier(
@@ -58,16 +58,16 @@ class SliderBindableUi(
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef[float]):
+    def bind_value(self, value: TGetterOrReadonlyRef[float]):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
             self.element.update()
 
         return self

ex4nicegui/reactive/officials/switch.py

@@ -47,15 +47,15 @@ class SwitchBindableUi(BindableUi[ui.switch]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef[bool]):
+    def bind_value(self, value: TGetterOrReadonlyRef[bool]):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
 
         return self

ex4nicegui/reactive/officials/tab.py

@@ -33,12 +33,6 @@ class TabBindableUi(BindableUi[ui.tab]):
         for key, value in bindings_kws.items():
             self.bind_prop(key, value)  # type: ignore
 
-    # def bind_prop(self, prop: str, ref_ui: TMaybeRef):
-    #     if prop == "name":
-    #         return self.bind_name(ref_ui)
-
-    #     return super().bind_prop(prop, ref_ui)
-
     def __bind_label(self, binding_kws: Dict, value_kws: Dict):
         name_ref = binding_kws.get("name") or value_kws.get("name")
         label_ref = binding_kws.get("label") or value_kws.get("label")
@@ -49,9 +43,3 @@ class TabBindableUi(BindableUi[ui.tab]):
                 to_value(label_ref) if label_ref is not None else to_value(name_ref)
             )
             self.element.update()
-
-    # def bind_name(self, ref_ui: TMaybeRef):
-    #     @self._ui_effect
-    #     def _():
-    #         self.element._props["name"] = to_value(ref_ui)
-    #         self.element.update()

ex4nicegui/reactive/officials/tab_panels.py

@@ -1,11 +1,14 @@
-from typing import Any, Callable, Optional
+import inspect
+from typing import Any, Awaitable, Callable, Optional, Union
+from weakref import WeakValueDictionary
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     to_value,
     _TMaybeRef as TMaybeRef,
 )
-from nicegui import ui
+from ex4nicegui.utils.scheduler import next_tick
+from nicegui import ui, background_tasks, core
 from .base import BindableUi
 
 
@@ -46,13 +49,116 @@ class TabPanelsBindableUi(BindableUi[ui.tab_panels]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_value(self, value: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
+
+
+class lazy_tab_panel(ui.tab_panel):
+    def __init__(self, name: str) -> None:
+        super().__init__(name)
+        self._build_fn = None
+
+    def try_run_build_fn(self):
+        if self._build_fn:
+            _helper.run_build_fn(self, self._props["name"])
+            self._build_fn = None
+
+    def build_fn(self, fn: Callable[..., Union[None, Awaitable]]):
+        self._build_fn = fn
+        return fn
+
+
+class LazyTabPanelsBindableUi(TabPanelsBindableUi):
+    def __init__(
+        self,
+        value: Optional[TMaybeRef[str]] = None,
+        *,
+        on_change: Optional[Callable[..., Any]] = None,
+        animated: TMaybeRef[bool] = True,
+        keep_alive: TMaybeRef[bool] = True,
+    ) -> None:
+        """Lazy Tab Panels
+
+        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#lazy_tab_panels
+        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#lazy_tab_panels
+
+        Args:
+            value (Optional[TMaybeRef[str]], optional): The value of the tab panel. Defaults to None.
+            on_change (Optional[Callable[..., Any]], optional):  The callback function when the value of the tab panel changes. Defaults to None.
+            animated (TMaybeRef[bool], optional):  Whether to animate the tab panel. Defaults to True.
+            keep_alive (TMaybeRef[bool], optional):  Whether to keep the tab panel alive. Defaults to True.
+        """
+        super().__init__(
+            value, on_change=on_change, animated=animated, keep_alive=keep_alive
+        )
+
+        self.__panels: WeakValueDictionary[str, lazy_tab_panel] = WeakValueDictionary()
+
+        if value:
+
+            @self._ui_effect
+            def _():
+                current_value = to_value(value)
+                if current_value in self.__panels:
+                    panel = self.__panels[current_value]
+
+                    @next_tick
+                    def _():
+                        panel.try_run_build_fn()
+
+    def add_tab_panel(self, name: str):
+        def decorator(fn: Callable[..., Union[None, Awaitable]]):
+            with self:
+                panel = lazy_tab_panel(name)
+            str_name = panel._props["name"]
+            self.__panels[str_name] = panel
+            panel.build_fn(fn)
+
+            if self.value == name:
+                panel.try_run_build_fn()
+
+            return panel
+
+        return decorator
+
+
+class _helper:
+    @staticmethod
+    def run_build_fn(panel: lazy_tab_panel, name: str) -> None:
+        """ """
+        fn = panel._build_fn
+        if fn is None:
+            return
+        try:
+            expects_arguments = any(
+                p.default is inspect.Parameter.empty
+                and p.kind is not inspect.Parameter.VAR_POSITIONAL
+                and p.kind is not inspect.Parameter.VAR_KEYWORD
+                for p in inspect.signature(fn).parameters.values()
+            )
+
+            with panel:
+                result = fn(name) if expects_arguments else fn()
+            if isinstance(result, Awaitable):
+                # NOTE: await an awaitable result even if the handler is not a coroutine (like a lambda statement)
+                async def wait_for_result():
+                    with panel:
+                        try:
+                            await result
+                        except Exception as e:
+                            core.app.handle_exception(e)
+
+                if core.loop and core.loop.is_running():
+                    background_tasks.create(wait_for_result(), name=str(fn))
+                else:
+                    core.app.on_startup(wait_for_result())
+        except Exception as e:
+            core.app.handle_exception(e)

ex4nicegui/reactive/officials/table.py

@@ -145,22 +145,22 @@ class TableBindableUi(BindableUi[ui.table]):
         ]
         return cls(cols, rows, **other_kws)
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "dataframe":
-            return self.bind_dataframe(ref_ui)
+            return self.bind_dataframe(value)
 
         if prop == "rows":
-            return self.bind_rows(ref_ui)
+            return self.bind_rows(value)
 
         if prop == "columns":
-            return self.bind_columns(ref_ui)
+            return self.bind_columns(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_dataframe(self, ref_df: TGetterOrReadonlyRef):
+    def bind_dataframe(self, dataframe: TGetterOrReadonlyRef):
         @ref_computed
         def cp_converted_df():
-            df = ref_df.value
+            df = dataframe.value
             return utils_common.convert_dataframe(df)
 
         @ref_computed
@@ -182,20 +182,20 @@ class TableBindableUi(BindableUi[ui.table]):
 
         return self
 
-    def bind_rows(self, ref_ui: TGetterOrReadonlyRef[List[Dict]]):
-        @self._ui_signal_on(ref_ui, deep=True)
+    def bind_rows(self, rows: TGetterOrReadonlyRef[List[Dict]]):
+        @self._ui_signal_on(rows, deep=True)
         def _():
             ele = self.element
-            ele._props["rows"] = list(to_raw(to_value(ref_ui)))
+            ele._props["rows"] = list(to_raw(to_value(rows)))
             ele.update()
 
         return self
 
-    def bind_columns(self, ref_ui: TGetterOrReadonlyRef[List[Dict]]):
-        @self._ui_signal_on(ref_ui, deep=True)
+    def bind_columns(self, columns: TGetterOrReadonlyRef[List[Dict]]):
+        @self._ui_signal_on(columns, deep=True)
         def _():
             ele = self.element
-            ele._props["columns"] = list(to_raw(to_value(ref_ui)))
+            ele._props["columns"] = list(to_raw(to_value(columns)))
             ele.update()
 
         return self

ex4nicegui/reactive/officials/tabs.py

@@ -32,13 +32,13 @@ class TabsBindableUi(BindableUi[ui.tabs]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_value(self, value: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))

ex4nicegui/reactive/officials/textarea.py

@@ -52,16 +52,16 @@ class TextareaBindableUi(BindableUi[ui.textarea]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef[str]):
+    def bind_value(self, value: TGetterOrReadonlyRef[str]):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
 
         return self
 

ex4nicegui/reactive/officials/tooltip.py

@@ -0,0 +1,40 @@
+from typing import Any
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    TGetterOrReadonlyRef,
+    to_value,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import BindableUi
+
+
+class TooltipBindableUi(BindableUi[ui.tooltip]):
+    def __init__(
+        self,
+        text: TMaybeRef[Any] = "",
+    ) -> None:
+        pc = ParameterClassifier(locals(), maybeRefs=["text"], events=[])
+
+        element = ui.tooltip(**pc.get_values_kws())
+        super().__init__(element)
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    @property
+    def text(self):
+        return self.element.text
+
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
+        if prop == "text":
+            return self.bind_text(value)
+
+        return super().bind_prop(prop, value)
+
+    def bind_text(self, text: TGetterOrReadonlyRef):
+        @self._ui_effect
+        def _():
+            self.element.set_text(str(to_value(text)))
+
+        return self

ex4nicegui/reactive/q_pagination.py

@@ -36,15 +36,15 @@ class PaginationBindableUi(BindableUi[ui.pagination]):
     def value(self):
         return self.element.value
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "value":
-            return self.bind_value(ref_ui)
+            return self.bind_value(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_value(self, ref_ui: TGetterOrReadonlyRef[int]):
+    def bind_value(self, value: TGetterOrReadonlyRef[int]):
         @self._ui_effect
         def _():
-            self.element.set_value(to_value(ref_ui))
+            self.element.set_value(to_value(value))
 
         return self

ex4nicegui/reactive/scopedStyle.py

@@ -1,5 +1,6 @@
 from nicegui.element import Element
 from ex4nicegui.helper import client_instance_locker
+from nicegui import ui
 
 
 class ScopedStyle(Element, component="scopedStyle.js"):
@@ -7,7 +8,9 @@ class ScopedStyle(Element, component="scopedStyle.js"):
 
     @staticmethod
     def get():
-        return _scoped_style_factory.get_object()
+        if not ui.context.slot_stack:
+            return None
+        return _scoped_style_factory.get_object(ui.context.client)
 
     def create_style(self, element: Element, css: str):
         element_id = f"c{element.id}"