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

ex4nicegui/reactive/officials/button.py

@@ -10,10 +10,21 @@ from ex4nicegui.utils.signals import (
     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] = "",
@@ -33,28 +44,50 @@ class ButtonBindableUi(BindableUi[ui.button], DisableableMixin):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
-    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 == "icon":
-            return self.bind_icon(ref_ui)
+            return self.bind_icon(value)
+        if prop == "color":
+            return self.bind_color(value)
+
+        return super().bind_prop(prop, value)
+
+    def bind_color(self, color: TGetterOrReadonlyRef[str]):
+        """Binds the background color of the button.
+
+        Args:
+            color (TGetterOrReadonlyRef[str]): Getter or readonly reference to the color.
 
-        return super().bind_prop(prop, ref_ui)
+        """
+        BackgroundColorableMixin.bind_color(self, color)
+        return self
+
+    def bind_text_color(self, text_color: TGetterOrReadonlyRef[str]):
+        """Binds the text color of the button.
+
+        Args:
+            text_color (TGetterOrReadonlyRef[str]):  Getter or readonly reference to the color.
+
+        """
+        TextColorableMixin.bind_color(self, text_color)
+        return self
 
-    def bind_text(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_text(self, text: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
             ele = self.element
-            ele._props["label"] = to_value(ref_ui)
+            ele._props["label"] = to_value(text)
             ele.update()
 
         return self
 
-    def bind_icon(self, ref_ui: TGetterOrReadonlyRef[str]):
+    def bind_icon(self, icon: TGetterOrReadonlyRef[str]):
         @self._ui_effect
         def _():
             ele = self.element
-            ele._props["icon"] = to_value(ref_ui)
+            ele._props["icon"] = to_value(icon)
             ele.update()
 
         return self

ex4nicegui/reactive/officials/checkbox.py

@@ -43,16 +43,16 @@ class CheckboxBindableUi(BindableUi[ui.checkbox], DisableableMixin):
     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))
             self.element.update()
 
         return self

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, value: TGetterOrReadonlyRef):
+        if prop == "text":
+            return self.bind_text(value)
+
+        if prop == "color":
+            return self.bind_color(value)
+        if prop == "text-color":
+            return self.bind_text_color(value)
+
+        return super().bind_prop(prop, value)
+
+    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

@@ -10,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,
@@ -49,15 +49,17 @@ class CircularProgressBindableUi(
     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/color_picker.py

@@ -68,23 +68,23 @@ class ColorPickerBindableUi(BindableUi[ui.color_picker]):
     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_color(self, ref_ui: TGetterOrReadonlyRef[str]):
+    def bind_color(self, color: TGetterOrReadonlyRef[str]):
         @self._ui_effect
         def _():
-            self.element.set_color(to_value(ref_ui))
+            self.element.set_color(to_value(color))
 
         return self
 
-    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/column.py

@@ -20,14 +20,14 @@ class ColumnBindableUi(BindableUi[ui.column]):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         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: TGetterOrReadonlyRef):
-        self.bind_classes({"wrap": ref_ui})
+    def bind_wrap(self, value: TGetterOrReadonlyRef):
+        self.bind_classes({"wrap": value})
 
     def __enter__(self):
         self.element.__enter__()

ex4nicegui/reactive/officials/date.py

@@ -62,15 +62,15 @@ class DateBindableUi(BindableUi[ui.date]):
     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/dialog.py

@@ -0,0 +1,49 @@
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+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]):
+    def __init__(
+        self,
+        *,
+        value: TMaybeRef[bool] = False,
+    ) -> None:
+        pc = ParameterClassifier(locals(), maybeRefs=["value"])
+
+        value_kws = pc.get_values_kws()
+        element = ui.dialog(**value_kws)
+        super().__init__(element)  # type: ignore
+
+        if is_setter_ref(value):
+
+            def on_value_change():
+                value.value = element.value  # type: ignore
+
+            element.on_value_change(on_value_change)
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    @property
+    def value(self):
+        return self.element.value
+
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
+        if prop == "value":
+            return self.bind_value(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/echarts.py

@@ -119,31 +119,30 @@ class EChartsBindableUi(BindableUi[echarts]):
 
         ## Examples
 
-        ```python
-        rxui.echarts.from_javascript(
-            r'''(myChart) => {
-                option = {...};
-                myChart.setOption(option);
-            }
-        ''')
-        ```
+        .. code-block:: python
+            rxui.echarts.from_javascript(
+                r'''(myChart) => {
+                    option = {...};
+                    myChart.setOption(option);
+                }
+            ''')
 
         """
         if isinstance(code, Path):
             code = code.read_text("utf8")
         return cls(code=code)
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         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[Dict]):
-        @self._ui_signal_on(ref_ui)
+    def bind_options(self, options: TGetterOrReadonlyRef[Dict]):
+        @self._ui_signal_on(options)
         def _():
             ele = self.element
-            ele.update_options(to_raw(to_value(ref_ui)), self.__update_setting)
+            ele.update_options(to_raw(to_value(options)), self.__update_setting)
             ele.update()
 
         return self
@@ -171,58 +170,57 @@ class EChartsBindableUi(BindableUi[echarts]):
         ---
 
         ### click event:
-        ```python
-        bar = rxui.echarts(opts)
 
-        def on_click(e):
-            ui.notify(f"on_click:{e}")
+        .. code-block:: python
+            bar = rxui.echarts(opts)
+
+            def on_click(e):
+                ui.notify(f"on_click:{e}")
 
-        bar.on("click", on_click)
-        ```
+            bar.on("click", on_click)
 
         ---
 
         ### Use query to trigger callback of the specified component:
 
-        ```python
-        ...
-        def on_line_click(e):
-            ui.notify(e)
+        .. code-block:: python
+            ...
+            def on_line_click(e):
+                ui.notify(e)
+
+            bar.on("click", on_line_click,query='series.line')
 
-        bar.on("click", on_line_click,query='series.line')
-        ```
 
         ---
         ### only trigger for specified series
-        ```python
-
-        opts = {
-            "xAxis": {"type": "value", "boundaryGap": [0, 0.01]},
-            "yAxis": {
-                "type": "category",
-                "data": ["Brazil", "Indonesia", "USA", "India", "China", "World"],
-            },
-            "series": [
-                {
-                    "name": "first",
-                    "type": "bar",
-                    "data": [18203, 23489, 29034, 104970, 131744, 630230],
-                },
-                {
-                    "name": "second",
-                    "type": "bar",
-                    "data": [19325, 23438, 31000, 121594, 134141, 681807],
+
+        .. code-block:: python
+            opts = {
+                "xAxis": {"type": "value", "boundaryGap": [0, 0.01]},
+                "yAxis": {
+                    "type": "category",
+                    "data": ["Brazil", "Indonesia", "USA", "India", "China", "World"],
                 },
-            ],
-        }
+                "series": [
+                    {
+                        "name": "first",
+                        "type": "bar",
+                        "data": [18203, 23489, 29034, 104970, 131744, 630230],
+                    },
+                    {
+                        "name": "second",
+                        "type": "bar",
+                        "data": [19325, 23438, 31000, 121594, 134141, 681807],
+                    },
+                ],
+            }
 
-        bar = rxui.echarts(opts)
+            bar = rxui.echarts(opts)
 
-        def on_first_series_mouseover(e):
-            ui.notify(f"on_first_series_mouseover:{e}")
+            def on_first_series_mouseover(e):
+                ui.notify(f"on_first_series_mouseover:{e}")
 
-        bar.on("mouseover", on_first_series_mouseover, query={"seriesName": "first"})
-        ```
+            bar.on("mouseover", on_first_series_mouseover, query={"seriesName": "first"})
 
         ---
         """

ex4nicegui/reactive/officials/expansion.py

@@ -45,16 +45,16 @@ class ExpansionBindableUi(BindableUi[ui.expansion]):
     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))
 
         return self
 

ex4nicegui/reactive/officials/grid.py

@@ -1,6 +1,7 @@
 from typing import (
     Any,
     Optional,
+    Union,
 )
 
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
@@ -13,8 +14,8 @@ from ex4nicegui.utils.signals import _TMaybeRef as TMaybeRef
 class GridBindableUi(BindableUi[ui.grid]):
     def __init__(
         self,
-        rows: Optional[TMaybeRef[int]] = None,
-        columns: Optional[TMaybeRef[int]] = None,
+        rows: Optional[TMaybeRef[Union[int, str]]] = None,
+        columns: Optional[TMaybeRef[Union[int, str]]] = None,
     ) -> None:
         pc = ParameterClassifier(locals(), maybeRefs=["rows", "columns"], events=[])
 

ex4nicegui/reactive/officials/icon.py

@@ -13,10 +13,10 @@ from nicegui.elements.mixins.color_elements import (
     TextColorElement,
 )
 from .base import BindableUi
-from ex4nicegui.reactive.services import color_service
+from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
 
 
-class IconBindableUi(BindableUi[ui.icon]):
+class IconBindableUi(BindableUi[ui.icon], TextColorableMixin):
     def __init__(
         self,
         name: TMaybeRef[str],
@@ -34,23 +34,20 @@ class IconBindableUi(BindableUi[ui.icon]):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "name":
-            return self.bind_name(ref_ui)
+            return self.bind_name(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_name(self, ref_ui: TGetterOrReadonlyRef):
+    def bind_name(self, name: TGetterOrReadonlyRef):
         @self._ui_effect
         def _():
             ele = cast(TextColorElement, self.element)
-            ele._props["name"] = to_value(ref_ui)
+            ele._props["name"] = to_value(name)
             ele.update()
 
         return self

ex4nicegui/reactive/officials/image.py

@@ -25,13 +25,13 @@ class ImageBindableUi(BindableUi[ui.image]):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
-    def bind_prop(self, prop: str, ref_ui: TGetterOrReadonlyRef):
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
         if prop == "source":
-            return self.bind_source(ref_ui)
+            return self.bind_source(value)
 
-        return super().bind_prop(prop, ref_ui)
+        return super().bind_prop(prop, value)
 
-    def bind_source(self, ref_ui: TGetterOrReadonlyRef[Union[str, Path]]):
+    def bind_source(self, source: TGetterOrReadonlyRef[Union[str, Path]]):
         @self._ui_effect
         def _():
-            self.element.set_source(to_value(ref_ui))
+            self.element.set_source(to_value(source))

ex4nicegui/reactive/officials/input.py

@@ -51,26 +51,26 @@ class InputBindableUi(BindableUi[ui.input], DisableableMixin):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
-    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 == "password":
-            return self.bind_password(ref_ui)
+            return self.bind_password(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))
             self.element.update()
 
         return self
 
-    def bind_password(self, ref_ui: TGetterOrReadonlyRef[bool]):
+    def bind_password(self, password: TGetterOrReadonlyRef[bool]):
         @self._ui_effect
         def _():
-            self.element._props["type"] = "password" if to_value(ref_ui) else "text"
+            self.element._props["type"] = "password" if to_value(password) else "text"
             self.element.update()
 
         return self