ex4nicegui 0.6.7__py3-none-any.whl → 0.6.9__py3-none-any.whl

ex4nicegui/reactive/mixins/textColor.py

@@ -0,0 +1,66 @@
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Protocol,
+)
+
+import signe
+from ex4nicegui.utils.signals import (
+    TGetterOrReadonlyRef,
+    WatchedState,
+)
+from nicegui import ui
+from ex4nicegui.reactive.systems import color_system
+
+
+class TextColorableMixin(Protocol):
+    _ui_signal_on: Callable[[Callable[[TGetterOrReadonlyRef[str]], Any]], signe.Effect]
+
+    @property
+    def element(self) -> ui.element:
+        ...
+
+    def _bind_text_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+        @self._ui_signal_on(ref_ui)  # type: ignore
+        def _(state: WatchedState):
+            if state.previous is not None:
+                color_system.remove_text_color(self.element, state.previous)
+
+            color_system.add_text_color(self.element, state.current)
+
+            self.element.update()
+
+    def bind_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+        """bind text color to the element
+
+        Args:
+            ref_ui (TGetterOrReadonlyRef[str]): a reference to the color value
+
+        """
+        self._bind_text_color(ref_ui)
+        return self
+
+
+class HtmlTextColorableMixin(Protocol):
+    _ui_signal_on: Callable[[Callable[[TGetterOrReadonlyRef[str]], Any]], signe.Effect]
+
+    @property
+    def element(self) -> ui.element:
+        ...
+
+    def bind_style(self, style: Dict[str, TGetterOrReadonlyRef[Any]]):
+        ...
+
+    def _bind_text_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+        return self.bind_style({"color": ref_ui})
+
+    def bind_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+        """bind text color to the element
+
+        Args:
+            ref_ui (TGetterOrReadonlyRef[str]): a reference to the color value
+
+        """
+        self._bind_text_color(ref_ui)
+        return self

ex4nicegui/reactive/officials/aggrid.py

@@ -9,13 +9,13 @@ from ex4nicegui.utils.signals import (
     is_ref,
     ref_computed,
     to_value,
-    _TMaybeRef as TMaybeRef,
+    TMaybeRef,
     TGetterOrReadonlyRef,
 )
-from ex4nicegui.utils.apiEffect import ui_effect
 from nicegui import ui
 from .base import BindableUi
-from ex4nicegui.reactive.utils import ParameterClassifier, dataframe2col_str
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.services.pandas_service import dataframe2col_str
 
 
 class AggridBindableUi(BindableUi[ui.aggrid]):
@@ -85,7 +85,7 @@ class AggridBindableUi(BindableUi[ui.aggrid]):
         return super().bind_prop(prop, ref_ui)
 
     def bind_options(self, ref_ui: TGetterOrReadonlyRef[List[Dict]]):
-        @ui_effect
+        @self._ui_effect
         def _():
             ele = self.element
             data = to_value(ref_ui)

ex4nicegui/reactive/officials/base.py

@@ -1,352 +1,5 @@
-from __future__ import annotations
-
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Protocol,
-    TypeVar,
-    Generic,
-    Union,
-    cast,
-    Literal,
+from ex4nicegui.reactive.base import (
+    BindableUi,  # noqa: F401
+    DisableableMixin,  # noqa: F401
+    DisableableBindableUi,  # noqa: F401
 )
-
-from typing_extensions import Self
-from ex4nicegui.utils.apiEffect import ui_effect
-import signe
-from ex4nicegui.utils.signals import (
-    TGetterOrReadonlyRef,
-    effect,
-    to_value,
-    is_ref,
-    WatchedState,
-    on,
-)
-from nicegui import Tailwind, ui
-from nicegui.elements.mixins.color_elements import (
-    TextColorElement,
-    QUASAR_COLORS,
-    TAILWIND_COLORS,
-)
-from nicegui.elements.mixins.text_element import TextElement
-from nicegui.elements.mixins.disableable_element import DisableableElement
-
-
-T = TypeVar("T")
-
-
-TWidget = TypeVar("TWidget", bound=ui.element)
-
-_T_bind_classes_type_dict = Dict[str, TGetterOrReadonlyRef[bool]]
-_T_bind_classes_type_ref_dict = TGetterOrReadonlyRef[Dict[str, bool]]
-_T_bind_classes_type_array = List[TGetterOrReadonlyRef[str]]
-
-
-_T_bind_classes_type = Union[
-    _T_bind_classes_type_dict, _T_bind_classes_type_ref_dict, _T_bind_classes_type_array
-]
-
-
-class BindableUi(Generic[TWidget]):
-    def __init__(self, element: TWidget) -> None:
-        self._element = element
-        self.tailwind = Tailwind(cast(ui.element, self._element))
-
-    def _ui_effect(self, fn: Callable):
-        return ui_effect(fn)
-
-    def props(self, add: Optional[str] = None, *, remove: Optional[str] = None):
-        cast(ui.element, self.element).props(add, remove=remove)
-        return self
-
-    def classes(
-        self,
-        add: Optional[str] = None,
-        *,
-        remove: Optional[str] = None,
-        replace: Optional[str] = None,
-    ):
-        cast(ui.element, self.element).classes(add, remove=remove, replace=replace)
-        return self
-
-    def style(
-        self,
-        add: Optional[str] = None,
-        *,
-        remove: Optional[str] = None,
-        replace: Optional[str] = None,
-    ):
-        cast(ui.element, self.element).style(add, remove=remove, replace=replace)
-        return self
-
-    def __enter__(self) -> Self:
-        self.element.__enter__()
-        return self
-
-    def __exit__(self, *_):
-        self.element.default_slot.__exit__(*_)
-
-    def tooltip(self, text: str) -> Self:
-        cast(ui.element, self.element).tooltip(text)
-        return self
-
-    def add_slot(self, name: str, template: Optional[str] = None):
-        """Add a slot to the element.
-
-        :param name: name of the slot
-        :param template: Vue template of the slot
-        :return: the slot
-        """
-        return cast(ui.element, self.element).add_slot(name, template)
-
-    @property
-    def element(self):
-        return self._element
-
-    def delete(self) -> None:
-        """Delete the element."""
-        self.delete()
-
-    def move(
-        self, target_container: Optional[ui.element] = None, target_index: int = -1
-    ):
-        """Move the element to another container.
-
-        :param target_container: container to move the element to (default: the parent container)
-        :param target_index: index within the target slot (default: append to the end)
-        """
-        return self.move(target_container, target_index)
-
-    def remove(self, element: Union[ui.element, int]) -> None:
-        """Remove a child element.
-
-        :param element: either the element instance or its ID
-        """
-        return self.element.remove(element)
-
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef[Any]):
-        """data binding is manipulating an element's property
-
-        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind_prop
-        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#bind_prop
-
-        Args:
-            prop (str): property name
-            ref_ui (TGetterOrReadonlyRef[Any]): a reference to the value to bind to
-
-        """
-        if prop == "visible":
-            return self.bind_visible(ref_ui)
-
-        if prop == "text" and isinstance(self.element, TextElement):
-
-            @self._ui_effect
-            def _():
-                cast(TextElement, self.element).set_text(to_value(ref_ui))
-                self.element.update()
-
-        @self._ui_effect
-        def _():
-            element = cast(ui.element, self.element)
-            element._props[prop] = to_value(ref_ui)
-            element.update()
-
-        return self
-
-    def bind_visible(self, ref_ui: TGetterOrReadonlyRef[bool]):
-        @self._ui_effect
-        def _():
-            element = cast(ui.element, self.element)
-            element.set_visibility(to_value(ref_ui))
-
-        return self
-
-    def bind_not_visible(self, ref_ui: TGetterOrReadonlyRef[bool]):
-        return self.bind_visible(lambda: not to_value(ref_ui))
-
-    def on(
-        self,
-        type: str,
-        handler: Optional[Callable[..., Any]] = None,
-        args: Optional[List[str]] = None,
-        *,
-        throttle: float = 0.0,
-        leading_events: bool = True,
-        trailing_events: bool = True,
-    ):
-        ele = cast(ui.element, self.element)
-        ele.on(
-            type,
-            handler,
-            args,
-            throttle=throttle,
-            leading_events=leading_events,
-            trailing_events=trailing_events,
-        )
-
-        return self
-
-    def clear(self) -> None:
-        cast(ui.element, self.element).clear()
-
-    def bind_classes(self, classes: _T_bind_classes_type):
-        """data binding is manipulating an element's class list
-
-        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind-class-names
-        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#%E7%BB%91%E5%AE%9A%E7%B1%BB%E5%90%8D
-
-        Args:
-            classes (_T_bind_classes_type):
-        """
-        if isinstance(classes, dict):
-            for name, ref_obj in classes.items():
-
-                @self._ui_effect
-                def _(name=name, ref_obj=ref_obj):
-                    if to_value(ref_obj):
-                        self.classes(add=name)
-                    else:
-                        self.classes(remove=name)
-
-        elif is_ref(classes) or isinstance(classes, Callable):
-            ref_obj = to_value(classes)  # type: ignore
-            assert isinstance(ref_obj, dict)
-
-            @effect
-            def _():
-                for name, value in cast(Dict, to_value(classes)).items():  # type: ignore
-                    if value:
-                        self.classes(add=name)
-                    else:
-                        self.classes(remove=name)
-        elif isinstance(classes, list):
-            for ref_name in classes:
-                if is_ref(ref_name) or isinstance(ref_name, Callable):
-
-                    @on(ref_name)
-                    def _(state: WatchedState):
-                        self.classes(add=state.current, remove=state.previous)
-                else:
-                    self.classes(ref_name)  # type: ignore
-
-        return self
-
-    def bind_style(self, style: Dict[str, TGetterOrReadonlyRef[Any]]):
-        """data binding is manipulating an element's style
-
-        @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind-style
-        @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#bind-style
-
-        Args:
-            style (Dict[str, Union[ReadonlyRef[str], Ref[str]]]): _description_
-        """
-        if isinstance(style, dict):
-            for name, ref_obj in style.items():
-                if is_ref(ref_obj) or isinstance(ref_obj, Callable):
-
-                    @self._ui_effect
-                    def _(name=name, ref_obj=ref_obj):
-                        self.element._style[name] = str(to_value(ref_obj))
-                        self.element.update()
-
-        return self
-
-    def update(self):
-        """Update the element on the client side."""
-        self.element.update()
-
-
-# class SingleValueBindableUi(BindableUi[TWidget], Generic[T, TWidget]):
-#     def __init__(self, value: TMaybeRef[T], element: TWidget) -> None:
-#         super().__init__(element)
-#         self._ref = to_ref(value)
-
-#     @property
-#     def value(self) -> T:
-#         return self._ref.value  # type: ignore
-
-#     def bind_ref(self, ref: TRef[T]):
-#         @effect
-#         def _():
-#             ref.value = self._ref.value  # type: ignore
-
-#         return self
-
-
-_T_DisableableBinder = TypeVar("_T_DisableableBinder", bound=DisableableElement)
-
-
-class DisableableMixin(Protocol):
-    _ui_effect: Callable[[Callable[..., Any]], signe.Effect[None]]
-
-    @property
-    def element(self) -> DisableableElement:
-        ...
-
-    def bind_enabled(self, ref_ui: TGetterOrReadonlyRef[bool]):
-        @self._ui_effect
-        def _():
-            value = to_value(ref_ui)
-            self.element.set_enabled(value)
-            self.element._handle_enabled_change(value)
-
-        return self
-
-    def bind_disable(self, ref_ui: TGetterOrReadonlyRef[bool]):
-        @self._ui_effect
-        def _():
-            value = not to_value(ref_ui)
-            self.element.set_enabled(value)
-            self.element._handle_enabled_change(value)
-
-        return self
-
-
-DisableableBindableUi = DisableableMixin
-
-
-_color_sys_type = Literal["QUASAR", "TAILWIND", "STYLE"]
-_color_attr_name = "data-ex4ng-color"
-
-
-def _bind_color(bindable_ui: BindableUi, ref_ui: TGetterOrReadonlyRef):
-    @effect
-    def _():
-        ele = cast(TextColorElement, bindable_ui.element)
-        color = to_value(ref_ui)
-
-        # get exists color
-        # e.g 'QUASAR:red'
-        pre_color = ele._props.get(_color_attr_name)  # type: str | None
-        if pre_color:
-            color_sys, value = pre_color.split(":")  # type: ignore
-            color_sys: _color_sys_type
-
-            if color_sys == "QUASAR":
-                del ele._props[ele.TEXT_COLOR_PROP]
-            elif color_sys == "TAILWIND":
-                ele.classes(remove=value)
-            else:
-                del ele._style["color"]
-
-        cur_sys: _color_sys_type = "STYLE"
-        cur_color = color
-
-        if color in QUASAR_COLORS:
-            ele._props[ele.TEXT_COLOR_PROP] = color
-            cur_sys = "QUASAR"
-        elif color in TAILWIND_COLORS:
-            cur_color = f"text-{color}"
-            ele.classes(replace=cur_color)
-            cur_sys = "TAILWIND"
-        elif color is not None:
-            ele._style["color"] = color
-
-        ele._props[_color_attr_name] = f"{cur_sys}:{color}"
-
-        ele.update()
-
-    return bindable_ui

ex4nicegui/reactive/officials/button.py

@@ -3,17 +3,28 @@ from typing import (
     Callable,
     Optional,
 )
-from ex4nicegui.reactive.utils import ParameterClassifier
+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, DisableableMixin
+from .base import (
+    BindableUi,
+    DisableableMixin,
+)
+
+from ex4nicegui.reactive.mixins.backgroundColor import BackgroundColorableMixin
+from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
 
 
-class ButtonBindableUi(BindableUi[ui.button], DisableableMixin):
+class ButtonBindableUi(
+    BindableUi[ui.button],
+    DisableableMixin,
+    BackgroundColorableMixin,
+    TextColorableMixin,
+):
     def __init__(
         self,
         text: TMaybeRef[str] = "",
@@ -38,9 +49,31 @@ class ButtonBindableUi(BindableUi[ui.button], DisableableMixin):
             return self.bind_text(ref_ui)
         if prop == "icon":
             return self.bind_icon(ref_ui)
+        if prop == "color":
+            return self.bind_color(ref_ui)
 
         return super().bind_prop(prop, ref_ui)
 
+    def bind_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+        """Binds the background color of the button.
+
+        Args:
+            ref_ui (TGetterOrReadonlyRef[str]): Getter or readonly reference to the color.
+
+        """
+        BackgroundColorableMixin.bind_color(self, ref_ui)
+        return self
+
+    def bind_text_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+        """Binds the text color of the button.
+
+        Args:
+            ref_ui (TGetterOrReadonlyRef[str]):  Getter or readonly reference to the color.
+
+        """
+        TextColorableMixin.bind_color(self, ref_ui)
+        return self
+
     def bind_text(self, ref_ui: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():

ex4nicegui/reactive/officials/checkbox.py

@@ -4,8 +4,7 @@ from typing import (
     Optional,
     TypeVar,
 )
-from ex4nicegui.reactive.utils import ParameterClassifier
-from ex4nicegui.utils.apiEffect import ui_effect
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
@@ -51,7 +50,7 @@ class CheckboxBindableUi(BindableUi[ui.checkbox], DisableableMixin):
         return super().bind_prop(prop, ref_ui)
 
     def bind_value(self, ref_ui: TGetterOrReadonlyRef[bool]):
-        @ui_effect
+        @self._ui_effect
         def _():
             self.element.set_value(to_value(ref_ui))
             self.element.update()

ex4nicegui/reactive/officials/chip.py

@@ -0,0 +1,102 @@
+from typing import Any, Callable, Optional
+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
+from ex4nicegui.reactive.mixins.backgroundColor import BackgroundColorableMixin
+from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
+
+
+class ChipBindableUi(
+    BindableUi[ui.chip],
+    BackgroundColorableMixin,
+    TextColorableMixin,
+):
+    def __init__(
+        self,
+        text: TMaybeRef[str] = "",
+        *,
+        icon: Optional[TMaybeRef[str]] = None,
+        color: Optional[TMaybeRef[str]] = "primary",
+        text_color: Optional[TMaybeRef[str]] = None,
+        on_click: Optional[Callable[..., Any]] = None,
+        selectable: TMaybeRef[bool] = False,
+        selected: TMaybeRef[bool] = False,
+        on_selection_change: Optional[Callable[..., Any]] = None,
+        removable: TMaybeRef[bool] = False,
+        on_value_change: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=[
+                "text",
+                "icon",
+                "color",
+                "text_color",
+                "selectable",
+                "selected",
+                "removable",
+            ],
+            events=["on_click", "on_selection_change", "on_value_change"],
+        )
+
+        element = ui.chip(**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, ref_ui: TGetterOrReadonlyRef):
+        if prop == "text":
+            return self.bind_text(ref_ui)
+
+        if prop == "color":
+            return self.bind_color(ref_ui)
+        if prop == "text-color":
+            return self.bind_text_color(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_color(self, color: TGetterOrReadonlyRef):
+        """Binds the background color property of the chip to a ui element.
+
+        Args:
+            color (TGetterOrReadonlyRef): background color ui element or getter function
+
+        """
+        BackgroundColorableMixin.bind_color(self, color)
+        return self
+
+    def bind_text_color(self, color: TGetterOrReadonlyRef):
+        """Binds the text color property of the chip to a ui element.
+
+        Args:
+            color (TGetterOrReadonlyRef):  text color ui element or getter function
+
+
+        """
+        TextColorableMixin.bind_color(self, color)
+        return self
+
+    def bind_text(self, text: TGetterOrReadonlyRef):
+        """Binds the text property of the chip to a ui element.
+
+        Args:
+            text (TGetterOrReadonlyRef):  text ui element or getter function
+
+        """
+
+        @self._ui_effect
+        def _():
+            self.element.set_text(str(to_value(text)))
+            self.element.update()
+
+        return self

ex4nicegui/reactive/officials/circular_progress.py

@@ -1,8 +1,7 @@
 from typing import (
     Optional,
 )
-from ex4nicegui.reactive.utils import ParameterClassifier
-from ex4nicegui.utils.apiEffect import ui_effect
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
@@ -11,11 +10,11 @@ from ex4nicegui.utils.signals import (
 )
 from nicegui import ui
 from .base import BindableUi, DisableableMixin
+from ex4nicegui.reactive.mixins.backgroundColor import BackgroundColorableMixin
 
 
 class CircularProgressBindableUi(
-    BindableUi[ui.circular_progress],
-    DisableableMixin,
+    BindableUi[ui.circular_progress], DisableableMixin, BackgroundColorableMixin
 ):
     def __init__(
         self,
@@ -53,11 +52,13 @@ class CircularProgressBindableUi(
     def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
         if prop == "value":
             return self.bind_value(ref_ui)
+        if prop == "color":
+            return self.bind_color(ref_ui)
 
         return super().bind_prop(prop, ref_ui)
 
     def bind_value(self, ref_ui: TGetterOrReadonlyRef[float]):
-        @ui_effect
+        @self._ui_effect
         def _():
             self.element.set_value(to_value(ref_ui))
 

ex4nicegui/reactive/officials/color_picker.py

@@ -4,8 +4,7 @@ from typing import (
     Optional,
     cast,
 )
-from ex4nicegui.reactive.utils import ParameterClassifier
-from ex4nicegui.utils.apiEffect import ui_effect
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
@@ -76,14 +75,14 @@ class ColorPickerBindableUi(BindableUi[ui.color_picker]):
         return super().bind_prop(prop, ref_ui)
 
     def bind_color(self, ref_ui: TGetterOrReadonlyRef[str]):
-        @ui_effect
+        @self._ui_effect
         def _():
             self.element.set_color(to_value(ref_ui))
 
         return self
 
     def bind_value(self, ref_ui: TGetterOrReadonlyRef[bool]):
-        @ui_effect
+        @self._ui_effect
         def _():
             self.element.set_value(to_value(ref_ui))