ex4nicegui 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

ex4nicegui/reactive/EChartsComponent/events.py

@@ -1,5 +1,6 @@
 from typing import (
     Any,
+    Dict,
     Optional,
 )
 from dataclasses import dataclass, fields
@@ -11,16 +12,16 @@ from nicegui.events import (
 
 @dataclass(**KWONLY_SLOTS)
 class EChartsMouseEventArguments(UiEventArguments):
-    componentType: str
-    seriesType: str
-    seriesIndex: int
-    seriesName: str
-    name: str
-    dataIndex: int
-    data: dict
-    dataType: Optional[str]
-    value: Any
-    color: str
+    componentType: Optional[str] = None
+    seriesType: Optional[str] = None
+    seriesIndex: Optional[int] = None
+    seriesName: Optional[str] = None
+    name: Optional[str] = None
+    dataIndex: Optional[int] = None
+    data: Optional[Dict] = None
+    dataType: Optional[str] = None
+    value: Optional[Any] = None
+    color: Optional[str] = None
 
 
 _Mouse_Event_Arguments_Fields = [f.name for f in fields(EChartsMouseEventArguments)]

ex4nicegui/reactive/EChartsComponent/utils.py

@@ -26,19 +26,6 @@ def create_event_handler_args(
     event_name: _T_event_name, e: GenericEventArguments
 ) -> UiEventArguments:
     if is_mouse_event(event_name):
-        return EChartsMouseEventArguments(
-            sender=e.sender,
-            client=e.client,
-            componentType=e.args["componentType"],
-            seriesType=e.args["seriesType"],
-            seriesIndex=e.args["seriesIndex"],
-            seriesName=e.args["seriesName"],
-            name=e.args["name"],
-            dataIndex=e.args["dataIndex"],
-            data=e.args["data"],
-            dataType=e.args.get("dataType"),
-            value=e.args["value"],
-            color=e.args["color"],
-        )
+        return EChartsMouseEventArguments(sender=e.sender, client=e.client, **e.args)
 
     return GenericEventArguments(sender=e.sender, client=e.client, args=e.args)

ex4nicegui/reactive/__init__.py

@@ -59,7 +59,9 @@ from .officials.toggle import ToggleBindableUi as toggle
 from .officials.avatar import AvatarBindableUi as avatar
 from .officials.badge import BadgeBindableUi as badge
 from .officials.range import RangeBindableUi as range
-
+from .officials.range import LazyRangeBindableUi as lazy_range
+from .officials.tree import TreeBindableUi as tree
+from .officials.spinner import SpinnerBindableUi as spinner
 
 from .local_file_picker import local_file_picker
 from .UseDraggable.UseDraggable import use_draggable
@@ -142,4 +144,7 @@ __all__ = [
     "avatar",
     "badge",
     "range",
+    "lazy_range",
+    "tree",
+    "spinner",
 ]

ex4nicegui/reactive/officials/grid.py

@@ -8,14 +8,21 @@ from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 
 from nicegui import ui
 from .base import BindableUi
-from ex4nicegui.utils.signals import _TMaybeRef as TMaybeRef
+from ex4nicegui.utils.signals import (
+    _TMaybeRef as TMaybeRef,
+    TGetterOrReadonlyRef,
+    to_value,
+)
+
+
+_T_Template = Union[TMaybeRef[str], TMaybeRef[int]]
 
 
 class GridBindableUi(BindableUi[ui.grid]):
     def __init__(
         self,
-        rows: Optional[TMaybeRef[Union[int, str]]] = None,
-        columns: Optional[TMaybeRef[Union[int, str]]] = None,
+        rows: Optional[_T_Template] = None,
+        columns: Optional[_T_Template] = None,
     ) -> None:
         pc = ParameterClassifier(locals(), maybeRefs=["rows", "columns"], events=[])
 
@@ -25,6 +32,39 @@ class GridBindableUi(BindableUi[ui.grid]):
         for key, value in pc.get_bindings().items():
             self.bind_prop(key, value)  # type: ignore
 
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
+        if prop == "rows":
+            return self.bind_rows(value)
+
+        if prop == "columns":
+            return self.bind_columns(value)
+
+        return super().bind_prop(prop, value)
+
+    def bind_rows(self, rows: TGetterOrReadonlyRef[Union[int, str]]):
+        def template():
+            _rows = to_value(rows)
+            return (
+                f"repeat({_rows}, minmax(0, 1fr))" if isinstance(_rows, int) else _rows
+            )
+
+        self.bind_style({"grid-template-rows": template})
+
+        return self
+
+    def bind_columns(self, columns: TGetterOrReadonlyRef[Union[int, str]]):
+        def template():
+            _columns = to_value(columns)
+            return (
+                f"repeat({_columns}, minmax(0, 1fr))"
+                if isinstance(_columns, int)
+                else _columns
+            )
+
+        self.bind_style({"grid-template-columns": template})
+
+        return self
+
     def __enter__(self):
         self.element.__enter__()
         return self

ex4nicegui/reactive/officials/input.py

@@ -64,9 +64,32 @@ class InputBindableUi(
         if prop == "password":
             return self.bind_password(value)
 
+        if prop == "autocomplete":
+            return self.bind_autocomplete(value)
+
         return super().bind_prop(prop, value)
 
+    def bind_autocomplete(self, autocomplete: TGetterOrReadonlyRef[List[str]]):
+        """Binds the autocomplete attribute of the input element.
+
+        Args:
+            autocomplete (TGetterOrReadonlyRef[List[str]]):  The getter or readonly reference to the autocomplete list.
+        """
+
+        @self._ui_signal_on(autocomplete)
+        def _():
+            self.element.set_autocomplete(to_value(autocomplete))
+
+        return self
+
     def bind_password(self, password: TGetterOrReadonlyRef[bool]):
+        """Binds the password attribute of the input element.
+
+        Args:
+            password (TGetterOrReadonlyRef[bool]): The getter or readonly reference to the password state.
+
+        """
+
         @self._ui_signal_on(password)
         def _():
             self.element._props["type"] = "password" if to_value(password) else "text"

ex4nicegui/reactive/officials/radio.py

@@ -8,6 +8,9 @@ from typing import (
     Union,
 )
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.systems.reactive_system import (
+    convert_to_none_if_outside_options,
+)
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
@@ -51,8 +54,8 @@ class RadioBindableUi(BindableUi[ui.radio], ValueElementMixin[Any]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if ValueElementMixin._bind_specified_props(self, prop, value):
-            return self
+        if prop == "value":
+            return self.bind_value(value)
 
         if prop == "options":
             return self.bind_options(value)
@@ -66,3 +69,11 @@ class RadioBindableUi(BindableUi[ui.radio], ValueElementMixin[Any]):
             self.element.set_options(to_value(options))
 
         return self
+
+    def bind_value(self, value: TGetterOrReadonlyRef):
+        @self._ui_signal_on(value, deep=True)
+        def _():
+            new_value = convert_to_none_if_outside_options(value, self.element.options)
+            self.element.set_value(new_value)
+
+        return self

ex4nicegui/reactive/officials/range.py

@@ -1,11 +1,13 @@
 from typing import Any, Callable, Optional, Dict, cast
 
 
+from ex4nicegui.utils.signals import to_value, is_setter_ref
 from ex4nicegui.utils.signals import (
     _TMaybeRef as TMaybeRef,
 )
 
 from nicegui import ui
+from nicegui.events import handle_event
 from ex4nicegui.reactive.base import BindableUi, DisableableMixin
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
@@ -43,3 +45,43 @@ class RangeBindableUi(
     @property
     def value(self):
         return cast(Dict[str, int], self.element.value)
+
+
+class LazyRangeBindableUi(
+    RangeBindableUi,
+):
+    def __init__(
+        self,
+        *,
+        min: TMaybeRef[float],  # pylint: disable=redefined-builtin
+        max: TMaybeRef[float],  # pylint: disable=redefined-builtin
+        step: TMaybeRef[float] = 1.0,
+        value: Optional[TMaybeRef[Dict[str, int]]] = None,
+        on_change: Optional[Callable[..., Any]] = None,
+        on_update: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        """A lazy version of `rxui.range` that only updates the value when the user releases the range.
+
+        Args:
+            min (TMaybeRef[float]): lower bound of the range
+            max (TMaybeRef[float]): upper bound of the range
+            step (TMaybeRef[float], optional): step size. Defaults to 1.0.
+            value (Optional[TMaybeRef[Dict[str, int]]], optional): initial value to set min and max position of the range. Defaults to None.
+            on_change (Optional[Callable[..., Any]], optional): callback which is invoked when the user releases the range. Defaults to None.
+            on_update (Optional[Callable[..., Any]], optional): callback which is invoked when the component needs to change. Defaults to None.
+        """
+        super().__init__(
+            min=min,
+            max=max,
+            step=step,
+            value=lambda: to_value(value),  # type: ignore
+            on_change=on_update,
+        )
+
+        if is_setter_ref(value):
+
+            def new_on_change(e):
+                value.set_value(e.args)  # type: ignore
+                handle_event(on_change, e)
+
+            self.on("change", new_on_change)

ex4nicegui/reactive/officials/select.py

@@ -4,7 +4,6 @@ from typing import (
     List,
     Optional,
     TypeVar,
-    cast,
     Dict,
     Union,
 )
@@ -16,7 +15,6 @@ from ex4nicegui.utils.signals import (
     to_raw,
 )
 from nicegui import ui
-from nicegui.elements.mixins.value_element import ValueElement
 from .base import BindableUi
 
 T = TypeVar("T")
@@ -94,6 +92,6 @@ class SelectBindableUi(BindableUi[ui.select]):
         @self._ui_signal_on(value, deep=True)
         def _():
             ParameterClassifier.mark_event_source_as_internal(self.element)
-            cast(ValueElement, self.element).set_value(to_raw(to_value(value)) or None)
+            self.element.set_value(to_raw(to_value(value)) or None)
 
         return self

ex4nicegui/reactive/officials/spinner.py

@@ -0,0 +1,43 @@
+from typing import Optional
+
+
+from ex4nicegui.utils.signals import (
+    TGetterOrReadonlyRef,
+    _TMaybeRef as TMaybeRef,
+)
+
+from nicegui import ui
+from ex4nicegui.reactive.base import BindableUi
+from ex4nicegui.reactive.mixins.textColor import TextColorableMixin
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+
+from nicegui.elements.spinner import SpinnerTypes
+
+
+class SpinnerBindableUi(BindableUi[ui.spinner], TextColorableMixin):
+    def __init__(
+        self,
+        type: Optional[SpinnerTypes] = "default",
+        *,
+        size: TMaybeRef[str] = "1em",
+        color: Optional[TMaybeRef[str]] = "primary",
+        thickness: TMaybeRef[float] = 5.0,
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(), maybeRefs=["type", "size", "color", "thickness"]
+        )
+
+        value_kws = pc.get_values_kws()
+        element = ui.spinner(**value_kws)
+        super().__init__(element)  # type: ignore
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
+        if prop == "type":
+            raise ValueError("type cannot be bound")
+        elif prop == "color":
+            return self.bind_color(value)
+
+        return super().bind_prop(prop, value)

ex4nicegui/reactive/officials/toggle.py

@@ -8,11 +8,13 @@ from typing import (
     Union,
 )
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+from ex4nicegui.reactive.systems.reactive_system import (
+    convert_to_none_if_outside_options,
+)
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
     _TMaybeRef as TMaybeRef,
     to_value,
-    to_raw,
 )
 from nicegui import ui
 from .base import BindableUi
@@ -83,7 +85,7 @@ class ToggleBindableUi(BindableUi[ui.toggle]):
     def bind_value(self, value: TGetterOrReadonlyRef):
         @self._ui_signal_on(value, deep=True)
         def _():
-            ParameterClassifier.mark_event_source_as_internal(self.element)
-            self.element.set_value(to_raw(to_value(value)) or None)
+            new_value = convert_to_none_if_outside_options(value, self.element.options)
+            self.element.set_value(new_value)
 
         return self

ex4nicegui/reactive/officials/tree.py

@@ -0,0 +1,86 @@
+from typing import List, Literal, Optional, Dict
+
+from ex4nicegui.utils.signals import (
+    _TMaybeRef as TMaybeRef,
+)
+
+from nicegui import ui
+from nicegui.events import Handler, ValueChangeEventArguments
+from .base import BindableUi
+from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
+
+
+class TreeBindableUi(
+    BindableUi[ui.tree],
+):
+    def __init__(
+        self,
+        nodes: TMaybeRef[List[Dict]],
+        *,
+        selected: Optional[TMaybeRef[str]] = None,
+        node_key: str = "id",
+        label_key: str = "label",
+        children_key: str = "children",
+        on_select: Optional[Handler[ValueChangeEventArguments]] = None,
+        on_expand: Optional[Handler[ValueChangeEventArguments]] = None,
+        on_tick: Optional[Handler[ValueChangeEventArguments]] = None,
+        tick_strategy: Optional[
+            TMaybeRef[Literal["leaf", "leaf-filtered", "strict"]]
+        ] = None,
+    ) -> None:
+        """Tree
+
+        Display hierarchical data using Quasar's `QTree <https://quasar.dev/vue-components/tree>`_ component.
+
+        If using IDs, make sure they are unique within the whole tree.
+
+        To use checkboxes and ``on_tick``, set the ``tick_strategy`` parameter to "leaf", "leaf-filtered" or "strict".
+
+
+        Args:
+            nodes (TMaybeRef[List[Dict]]):  hierarchical list of node objects
+            selected (Optional[TMaybeRef[str]], optional): Key of node currently selected. Defaults to None.
+            node_key (str, optional):  property name of each node object that holds its unique id. Defaults to "id".
+            label_key (str, optional): property name of each node object that holds its label. Defaults to "label".
+            children_key (str, optional): property name of each node object that holds its list of children. Defaults to "children".
+            on_select (Optional[Handler[ValueChangeEventArguments]], optional): callback which is invoked when the node selection changes. Defaults to None.
+            on_expand (Optional[Handler[ValueChangeEventArguments]], optional): callback which is invoked when the node expansion changes. Defaults to None.
+            on_tick (Optional[Handler[ValueChangeEventArguments]], optional): callback which is invoked when a node is ticked or unticked. Defaults to None.
+            tick_strategy (Optional[ TMaybeRef[Literal[&quot;leaf&quot;, &quot;leaf, optional): whether and how to use checkboxes. Defaults to None.
+
+
+        Example:
+        .. code-block:: python
+            from ex4nicegui import to_ref, rxui
+
+            selected = to_ref("")
+            nodes = to_ref(
+                [
+                    {"id": "numbers", "children": [{"id": "1"}, {"id": "2"}]},
+                    {"id": "letters", "children": [{"id": "A"}, {"id": "B"}]},
+                ]
+            )
+
+            rxui.label(lambda: f"Selected node: {selected.value}")
+            rxui.tree(nodes, selected=selected, label_key="id")
+        """
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=[
+                "nodes",
+                "node_key",
+                "label_key",
+                "children_key",
+                "tick_strategy",
+            ],
+            v_model=("selected", "on_select"),
+            events=["on_select", "on_expand", "on_tick"],
+        )
+
+        value_kws = pc.get_values_kws()
+        value_kws.pop("selected")
+        element = ui.tree(**value_kws)
+        super().__init__(element)  # type: ignore
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore

ex4nicegui/reactive/systems/reactive_system.py

@@ -1,5 +1,5 @@
-from typing import Callable, Dict
-from ex4nicegui.utils.signals import to_value, to_raw
+from typing import Callable, Dict, List, Union
+from ex4nicegui.utils.signals import to_value, to_raw, TGetterOrReadonlyRef
 
 
 def convert_kws_ref2value(kws: Dict) -> Dict:
@@ -19,3 +19,14 @@ def inject_method(obj, method_name: str, new_handle: Callable):
         raise AttributeError(
             f"'{type(obj).__name__}' object has no attribute '{method_name}'."
         )
+
+
+def convert_to_none_if_outside_options(
+    value: TGetterOrReadonlyRef, options: Union[List, Dict]
+):
+    new_value = to_raw(to_value(value))
+
+    if new_value not in options:
+        new_value = None
+
+    return new_value

ex4nicegui/toolbox/__init__.py

@@ -0,0 +1,5 @@
+from .functions.dark import UseDark as use_dark
+from .functions.breakpoint import UseBreakpoints as use_breakpoints
+from .functions.qr_code import UseQRCode as use_qr_code
+
+__all__ = ["use_dark", "use_breakpoints", "use_qr_code"]