ex4nicegui 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

ex4nicegui/reactive/officials/date.py

@@ -0,0 +1,85 @@
+from typing import Any, Callable, List, Optional, TypeVar, cast
+from typing_extensions import TypedDict
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+
+_TDateRange = TypedDict("_TDateRange", {"from": str, "to": str})
+
+_TDateValue = TypeVar(
+    "_TDateValue", str, List[str], _TDateRange, List[_TDateRange], None
+)
+
+
+class DateBindableUi(SingleValueBindableUi[_TDateValue, ui.date]):
+    def __init__(
+        self,
+        value: Optional[TMaybeRef[_TDateValue]] = None,
+        *,
+        mask: TMaybeRef[str] = "YYYY-MM-DD",
+        on_change: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        """Date Input
+
+        This element is based on Quasar's `QDate <https://quasar.dev/vue-components/date>`_ component.
+        The date is a string in the format defined by the `mask` parameter.
+
+        You can also use the `range` or `multiple` props to select a range of dates or multiple dates::
+
+            ui.date({'from': '2023-01-01', 'to': '2023-01-05'}).props('range')
+            ui.date(['2023-01-01', '2023-01-02', '2023-01-03']).props('multiple')
+            ui.date([{'from': '2023-01-01', 'to': '2023-01-05'}, '2023-01-07']).props('multiple range')
+
+        :param value: the initial date
+        :param mask: the format of the date string (default: 'YYYY-MM-DD')
+        :param on_change: callback to execute when changing the date
+        """
+        kws = {
+            "value": value,
+            "mask": mask,
+            "on_change": on_change,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.date(**value_kws)
+
+        super().__init__(value, element)  # type: ignore
+
+        for key, value in kws.items():
+            if is_ref(value) and key != "value":
+                self.bind_prop(key, value)  # type: ignore
+
+        self._ex_setup()
+
+    def _ex_setup(self):
+        ele = self.element
+
+        @effect
+        def _():
+            ele.value = self.value
+
+        def onModelValueChanged(e):
+            self._ref.value = e.args[0] or ""  # type: ignore
+
+        ele.on("update:modelValue", handler=onModelValueChanged)
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_value(self, ref_ui: ReadonlyRef[bool]):
+        @effect
+        def _():
+            self.element.on_value_change(ref_ui.value)
+
+        return self

ex4nicegui/reactive/officials/drawer.py

@@ -0,0 +1,88 @@
+from typing import (
+    Any,
+)
+from typing_extensions import Literal
+from signe import effect
+from ex4nicegui.utils.signals import (
+    to_value,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from nicegui.page_layout import Drawer
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+_TDrawerSide = Literal["left", "right"]
+
+
+class DrawerBindableUi(SingleValueBindableUi[bool, Drawer]):
+    def __init__(
+        self,
+        side: TMaybeRef[_TDrawerSide] = "left",
+        overlay: TMaybeRef[bool] = False,
+        *,
+        value: TMaybeRef[bool] = True,
+        fixed: TMaybeRef[bool] = False,
+        bordered: TMaybeRef[bool] = True,
+        elevated: TMaybeRef[bool] = False,
+        top_corner: TMaybeRef[bool] = False,
+        bottom_corner: TMaybeRef[bool] = False,
+    ) -> None:
+        kws = {
+            "side": side,
+            "overlay": overlay,
+            "value": value,
+            "fixed": fixed,
+            "bordered": bordered,
+            "elevated": elevated,
+            "top_corner": top_corner,
+            "bottom_corner": bottom_corner,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+        del value_kws["side"]
+        del value_kws["overlay"]
+
+        element = None
+
+        if to_value(side) == "left":
+            element = ui.left_drawer(**value_kws)
+        else:
+            element = ui.right_drawer(**value_kws)
+
+        element.style(f"background-color:rgba(25, 118, 210,0.3)")
+        element.classes("flex flex-col gap-4")
+
+        init_value = (
+            element._props["model-value"]
+            if "model-value" in element._props
+            else element._props["show-if-above"]
+        )
+
+        super().__init__(value, element)
+
+        @effect
+        def _():
+            value = "true" if self.value else "false"
+            element.props(f":model-value={value}")
+
+        def on_update(e):
+            self._ref.value = e.args
+
+        element.on("update:modelValue", on_update)
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)  # type: ignore
+
+    def toggle(self):
+        self.element.toggle()
+        return self
+
+    def __enter__(self):
+        self.element.__enter__()
+        return self
+
+    def __exit__(self, *_: Any):
+        self.element.__exit__(*_)

ex4nicegui/reactive/officials/echarts.py

@@ -0,0 +1,70 @@
+from typing import (
+    Dict,
+)
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    ref_computed,
+    _TMaybeRef as TMaybeRef,
+)
+from .base import BindableUi
+from .utils import _convert_kws_ref2value
+from ex4nicegui.reactive.ECharts.ECharts import echarts
+
+
+class EChartsBindableUi(BindableUi[echarts]):
+    def __init__(
+        self,
+        options: TMaybeRef[Dict],
+    ) -> None:
+        kws = {
+            "options": options,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = echarts(**value_kws)
+
+        super().__init__(element)
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)  # type: ignore
+
+    @staticmethod
+    def _pyecharts2opts(chart):
+        import simplejson as json
+        from pyecharts.charts.chart import Base
+
+        if isinstance(chart, Base):
+            return json.loads(chart.dump_options())
+
+        return {}
+
+    @staticmethod
+    def from_pyecharts(chart: TMaybeRef):
+        if is_ref(chart):
+
+            @ref_computed
+            def chart_opt():
+                return EChartsBindableUi._pyecharts2opts(chart.value)
+
+            return EChartsBindableUi(chart_opt)
+
+        return EChartsBindableUi(EChartsBindableUi._pyecharts2opts(chart))
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "options":
+            return self.bind_options(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_options(self, ref_ui: ReadonlyRef[Dict]):
+        @effect
+        def _():
+            ele = self.element
+            ele.update_options(ref_ui.value)
+            ele.update()
+
+        return self

ex4nicegui/reactive/officials/html.py

@@ -0,0 +1,66 @@
+import asyncio
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+
+class HtmlBindableUi(SingleValueBindableUi[str, ui.html]):
+    @staticmethod
+    def _setup_(binder: "HtmlBindableUi"):
+        first = True
+
+        @effect
+        def _():
+            nonlocal first
+
+            async def task():
+                pass
+                await ui.run_javascript(
+                    f"getElement({binder.element.id}).innerText= '{binder.value}' ",
+                    respond=False,
+                )
+
+            if not first:
+                asyncio.run(task())
+            else:
+                first = False
+
+    def __init__(
+        self,
+        content: TMaybeRef[str] = "",
+    ) -> None:
+        kws = {
+            "content": content,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.html(**value_kws)
+
+        super().__init__(content, element)
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)  # type: ignore
+
+        HtmlBindableUi._setup_(self)
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "color":
+            return self.bind_color(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_color(self, ref_ui: ReadonlyRef):
+        @effect
+        def _():
+            ele = self.element
+            color = ref_ui.value
+            ele._style["color"] = color
+            ele.update()

ex4nicegui/reactive/officials/icon.py

@@ -0,0 +1,62 @@
+from typing import (
+    Optional,
+    cast,
+)
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from nicegui.elements.mixins.color_elements import (
+    TextColorElement,
+)
+from .base import SingleValueBindableUi, _bind_color
+from .utils import _convert_kws_ref2value
+
+
+class IconBindableUi(SingleValueBindableUi[str, ui.icon]):
+    def __init__(
+        self,
+        name: TMaybeRef[str],
+        *,
+        size: Optional[TMaybeRef[str]] = None,
+        color: Optional[TMaybeRef[str]] = None,
+    ) -> None:
+        kws = {
+            "name": name,
+            "size": size,
+            "color": color,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.icon(**value_kws)
+
+        super().__init__(name, element)
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)  # type: ignore
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "name":
+            return self.bind_name(ref_ui)
+
+        if prop == "color":
+            return self.bind_color(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_color(self, ref_ui: ReadonlyRef):
+        return _bind_color(self, ref_ui)
+
+    def bind_name(self, ref_ui: ReadonlyRef):
+        @effect
+        def _():
+            ele = cast(TextColorElement, self.element)
+            ele._props["name"] = ref_ui.value
+            ele.update()
+
+        return self

ex4nicegui/reactive/officials/image.py

@@ -0,0 +1,54 @@
+from pathlib import Path
+from typing import (
+    Union,
+)
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+
+class ImageBindableUi(SingleValueBindableUi[Union[str, Path], ui.image]):
+    @staticmethod
+    def _setup_(binder: "ImageBindableUi"):
+        @effect
+        def _():
+            binder.element.on_source_change(binder.value)
+
+    def __init__(
+        self,
+        source: Union[TMaybeRef[str], TMaybeRef[Path]] = "",
+    ) -> None:
+        kws = {
+            "source": source,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.image(**value_kws)
+
+        super().__init__(source, element)  # type: ignore
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)  # type: ignore
+
+        # ImageBindableUi._setup_(self)
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "source":
+            return self.bind_source(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_source(self, ref_ui: ReadonlyRef[Union[str, Path]]):
+        @effect
+        def _():
+            ele = self.element
+            source = ref_ui.value
+            ele.on_source_change(source)

ex4nicegui/reactive/officials/input.py

@@ -0,0 +1,116 @@
+from typing import (
+    Any,
+    Callable,
+    List,
+    Optional,
+    Dict,
+)
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+
+class InputBindableUi(SingleValueBindableUi[str, ui.input]):
+    def __init__(
+        self,
+        label: Optional[TMaybeRef[str]] = None,
+        *,
+        placeholder: Optional[TMaybeRef[str]] = None,
+        value: TMaybeRef[str] = "",
+        password: TMaybeRef[bool] = False,
+        password_toggle_button: TMaybeRef[bool] = False,
+        on_change: Optional[Callable[..., Any]] = None,
+        autocomplete: Optional[TMaybeRef[List[str]]] = None,
+        validation: Dict[str, Callable[..., bool]] = {},
+    ) -> None:
+        kws = {
+            "label": label,
+            "placeholder": placeholder,
+            "value": value,
+            "password": password,
+            "password_toggle_button": password_toggle_button,
+            "autocomplete": autocomplete,
+            "validation": validation,
+            "on_change": on_change,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.input(**value_kws)
+
+        super().__init__(value, element)
+
+        for key, value in kws.items():
+            if is_ref(value) and key != "value":
+                self.bind_prop(key, value)  # type: ignore
+
+        self._ex_setup()
+
+    def _ex_setup(self):
+        ele = self.element
+
+        @effect
+        def _():
+            ele.value = self.value
+
+        def onModelValueChanged(e):
+            self._ref.value = e.args or ""  # type: ignore
+
+        ele.on("update:modelValue", handler=onModelValueChanged)
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_value(self, ref_ui: ReadonlyRef[bool]):
+        @effect
+        def _():
+            self.element.on_value_change(ref_ui.value)
+
+        return self
+
+
+class LazyInputBindableUi(InputBindableUi):
+    def __init__(
+        self,
+        label: Optional[TMaybeRef[str]] = None,
+        *,
+        placeholder: Optional[TMaybeRef[str]] = None,
+        value: TMaybeRef[str] = "",
+        password: TMaybeRef[bool] = False,
+        password_toggle_button: TMaybeRef[bool] = False,
+        on_change: Optional[Callable[..., Any]] = None,
+        autocomplete: Optional[TMaybeRef[List[str]]] = None,
+        validation: Dict[str, Callable[..., bool]] = {},
+    ) -> None:
+        super().__init__(
+            label,
+            placeholder=placeholder,
+            value=value,
+            password=password,
+            password_toggle_button=password_toggle_button,
+            on_change=on_change,
+            autocomplete=autocomplete,
+            validation=validation,
+        )
+
+    def _ex_setup(self):
+        ele = self.element
+
+        @effect
+        def _():
+            ele.value = self.value
+
+        def onValueChanged():
+            self._ref.value = ele.value or ""
+
+        ele.on("blur", onValueChanged)
+        ele.on("keyup.enter", onValueChanged)

ex4nicegui/reactive/officials/label.py

@@ -0,0 +1,67 @@
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+
+class LabelBindableUi(SingleValueBindableUi[str, ui.label]):
+    @staticmethod
+    def _setup_(binder: "LabelBindableUi"):
+        def onValueChanged(e):
+            binder._ref.value = e.args["label"]  # type: ignore
+
+        @effect
+        def _():
+            binder.element.text = binder.value
+
+        binder.element.on("update:modelValue", handler=onValueChanged)
+
+    def __init__(
+        self,
+        text: TMaybeRef[str] = "",
+    ) -> None:
+        kws = {
+            "text": text,
+        }
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.label(**value_kws)
+
+        super().__init__(text, element)
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)  # type: ignore
+
+        LabelBindableUi._setup_(self)
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "text":
+            return self.bind_text(ref_ui)
+
+        if prop == "color":
+            return self.bind_color(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_color(self, ref_ui: ReadonlyRef):
+        @effect
+        def _():
+            ele = self.element
+            color = ref_ui.value
+            ele._style["color"] = color
+            ele.update()
+
+    def bind_text(self, ref_ui: ReadonlyRef):
+        @effect
+        def _():
+            self.element.on_text_change(str(ref_ui.value))
+            # self.element.update()
+
+        return self

ex4nicegui/reactive/officials/radio.py

@@ -0,0 +1,80 @@
+from typing import (
+    Any,
+    Callable,
+    List,
+    Optional,
+    TypeVar,
+    cast,
+    Dict,
+    Union,
+)
+from signe import effect
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    is_ref,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from nicegui.elements.mixins.value_element import ValueElement
+from .base import SingleValueBindableUi
+from .utils import _convert_kws_ref2value
+
+T = TypeVar("T")
+
+
+class RadioBindableUi(SingleValueBindableUi[bool, ui.radio]):
+    @staticmethod
+    def _setup_(binder: "RadioBindableUi"):
+        def onValueChanged(e):
+            binder._ref.value = binder.element.options[e.args]  # type: ignore
+
+        @effect
+        def _():
+            binder.element.value = binder.value
+
+        binder.element.on("update:modelValue", handler=onValueChanged)
+
+    def __init__(
+        self,
+        options: Union[TMaybeRef[List], TMaybeRef[Dict]],
+        *,
+        value: TMaybeRef[Any] = None,
+        on_change: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        kws = {"options": options, "value": value, "on_change": on_change}
+
+        value_kws = _convert_kws_ref2value(kws)
+
+        element = ui.radio(**value_kws)
+
+        super().__init__(value, element)
+
+        for key, value in kws.items():
+            if is_ref(value):
+                self.bind_prop(key, value)
+
+        RadioBindableUi._setup_(self)
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
+
+        if prop == "options":
+            return self.bind_options(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_options(self, ref_ui: ReadonlyRef):
+        @effect
+        def _():
+            self.element.options = ref_ui.value
+            self.element.update()
+
+        return self
+
+    def bind_value(self, ref_ui: ReadonlyRef):
+        @effect
+        def _():
+            cast(ValueElement, self.element).on_value_change(ref_ui.value)
+
+        return self