ex4nicegui 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

ex4nicegui/bi/elements/ui_date_picker.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Optional
+from nicegui import ui
+from nicegui.client import Client
+from nicegui.elements.select import Select
+from ex4nicegui import to_ref, ref_computed
+from ex4nicegui.utils.signals import Ref
+from ex4nicegui.bi.dataSource import Filter
+from .models import UiResult
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade, DataSource
+
+
+class UiDatePicker(ui.element, component="ui_date_picker.js"):
+    def __init__(self, date: str) -> None:
+        super().__init__()
+        self._props["id"] = self.id
+        self.value = date.replace("-", "/")
+        self._props["date"] = self.value
+
+
+class DatePickerResult(UiResult[UiDatePicker]):
+    def __init__(
+        self,
+        element: UiDatePicker,
+        dataSource: DataSource,
+        ref_value: Ref,
+    ) -> None:
+        super().__init__(element, dataSource)
+        self._ref_value = ref_value
+
+    @property
+    def value(self) -> str:
+        return self._ref_value.value
+
+
+def ui_date_picker(
+    self: DataSourceFacade, column: str, *, value: Optional[str] = None, **kwargs
+):
+    options = self._dataSource._idataSource.duplicates_column_values(self.data, column)
+    kwargs.update(
+        {
+            "options": options,
+            "label": column,
+        }
+    )
+
+    cp = UiDatePicker(value or "")
+    ref_value = to_ref(cp.value)
+
+    def onchange(e):
+        value = e.args
+
+        cp.value = value
+        ref_value.value = value  # type: ignore
+
+        def data_filter(data):
+            if cp.value is None or not cp.value:
+                return data
+
+            cond = None
+            cond = data[column] == cp.value
+            return data[cond]
+
+        self._dataSource.send_filter(cp.id, Filter(data_filter))
+
+    cp.on("update:value", onchange)
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp)
+        # options = self._dataSource._idataSource.duplicates_column_values(data, column)
+        # value = cp.value
+
+    self._dataSource._register_component(cp.id, on_source_update)
+
+    return DatePickerResult(cp, self._dataSource, ref_value)

ex4nicegui/bi/elements/ui_echarts.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Union, cast
+from nicegui.events import UiEventArguments
+from ex4nicegui.reactive import rxui
+from ex4nicegui.reactive.EChartsComponent.ECharts import (
+    EChartsClickEventArguments,
+    echarts,
+)
+from nicegui import ui
+from ex4nicegui.bi.dataSource import DataSource
+from .models import UiResult
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade
+
+
+class EChartsResult(UiResult[echarts]):
+    def __init__(
+        self, element: echarts, dataSource: DataSource, chart_update: Callable
+    ) -> None:
+        super().__init__(element, dataSource)
+        self.chart_update = chart_update
+
+    def on_chart_click(
+        self, handler: Optional[Callable[[EChartsClickEventArguments], Any]]
+    ):
+        return self.element.on_chart_click(handler)
+
+    def on_chart_click_blank(
+        self, handler: Optional[Callable[[UiEventArguments], Any]]
+    ):
+        return self.element.on_chart_click_blank(handler)
+
+    def cancel_linkage(self, *source: Union[ui.element, "UiResult"]):
+        super().cancel_linkage(*source)
+        self.element.update_options(
+            self.chart_update(self._dataSource.get_filtered_data(self.element))
+        )
+
+
+def ui_echarts(
+    self: DataSourceFacade,
+    fn: Callable[[Any], Union[Dict, "pyecharts.Base"]],  # pyright: ignore
+    **kwargs,
+):
+    def create_options(data):
+        options = fn(data)
+        if isinstance(options, Dict):
+            return options
+
+        import simplejson as json
+        from pyecharts.charts.chart import Base
+
+        if isinstance(options, Base):
+            return cast(Dict, json.loads(options.dump_options()))
+
+        raise TypeError(f"not support options type[{type(options)}]")
+
+    cp = rxui.echarts({})
+    ele_id = cp.element.id
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp.element)
+        options = create_options(data)
+        cp.element.update_options(options)
+
+    info = self._dataSource._register_component(ele_id, on_source_update)
+
+    cp.element.update_options(
+        create_options(self._dataSource.get_filtered_data(cp.element))
+    )
+    return EChartsResult(cp.element, self._dataSource, create_options)

ex4nicegui/bi/elements/ui_radio.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from nicegui import ui
+from nicegui.elements.radio import Radio
+from ex4nicegui import to_ref
+from ex4nicegui.utils.signals import Ref
+from ex4nicegui.bi.dataSource import DataSource, Filter
+from .models import UiResult
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade
+
+
+class RadioResult(UiResult[ui.radio]):
+    def __init__(
+        self,
+        element: Radio,
+        dataSource: DataSource,
+        ref_value: Ref,
+    ) -> None:
+        super().__init__(element, dataSource)
+        self._ref_value = ref_value
+
+    @property
+    def value(self):
+        return self._ref_value.value
+
+
+def ui_radio(self: DataSourceFacade, column: str, **kwargs) -> RadioResult:
+    options = self._dataSource._idataSource.duplicates_column_values(self.data, column)
+    kwargs.update({"options": options})
+
+    cp = ui.radio(**kwargs)
+    ref_value = to_ref(cp.value)
+
+    def onchange(e):
+        cp.value = cp.options[e.args]
+
+        def data_filter(data):
+            if cp.value not in cp.options:
+                return data
+            cond = data[column] == cp.value
+            return data[cond]
+
+        self._dataSource.send_filter(cp.id, Filter(data_filter))
+
+    cp.on("update:modelValue", onchange)
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp)
+        options = self._dataSource._idataSource.duplicates_column_values(data, column)
+        value = cp.value
+        if value not in options:
+            value = ""
+
+        cp.set_options(options, value=value)
+
+    self._dataSource._register_component(cp.id, on_source_update)
+
+    return RadioResult(cp, self._dataSource, ref_value)

ex4nicegui/bi/elements/ui_range.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+from nicegui import ui
+from ex4nicegui import to_ref
+from ex4nicegui.utils.signals import Ref
+from ex4nicegui.bi.dataSource import Filter
+from .models import UiResult
+from typing import Any, Callable, Optional, TYPE_CHECKING, cast
+from typing_extensions import TypedDict
+
+
+from nicegui.elements.mixins.disableable_element import DisableableElement
+from nicegui.elements.mixins.value_element import ValueElement
+
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade, DataSource
+
+
+class QRangeValue(TypedDict):
+    min: float
+    max: float
+
+
+TQRangeValue = Optional[QRangeValue]
+
+
+class QRange(ValueElement, DisableableElement):
+    def __init__(
+        self,
+        *,
+        min: float,  # pylint: disable=redefined-builtin
+        max: float,  # pylint: disable=redefined-builtin
+        step: float = 1.0,
+        value: TQRangeValue = None,
+        on_change: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        """Slider
+
+        :param min: lower bound of the slider
+        :param max: upper bound of the slider
+        :param step: step size
+        :param value: initial value to set position of the slider
+        :param on_change: callback which is invoked when the user releases the slider
+        """
+        super().__init__(
+            tag="q-range", value=value, on_value_change=on_change, throttle=0.05
+        )
+        self._props["min"] = min
+        self._props["max"] = max
+        self._props["step"] = step
+
+
+class RangeResult(UiResult[QRange]):
+    def __init__(
+        self,
+        element: QRange,
+        dataSource: DataSource,
+        ref_value: Ref,
+    ) -> None:
+        super().__init__(element, dataSource)
+        self._ref_value = ref_value
+
+    @property
+    def value(self):
+        return cast(TQRangeValue, self._ref_value.value)
+
+    def drag_range(self):
+        self.element.props("drag-range")
+        return self
+
+
+def ui_range(self: DataSourceFacade, column: str, **kwargs):
+    self._dataSource._idataSource.slider_check(self.data, column)
+
+    min, max = self._dataSource._idataSource.range_min_max(self.data, column)
+    kwargs.update({"min": min, "max": max, "value": {"min": min, "max": max}})
+
+    with ui.element("q-item").classes("w-full"):
+        with ui.element("q-item-section").props("avatar"):
+            ui.label(column)
+        with ui.element("q-item-section"):
+            cp = QRange(**kwargs).props("label")
+
+    ref_value = to_ref(cast(TQRangeValue, cp.value))
+
+    def onchange():
+        def data_filter(data):
+            cp_value = cast(TQRangeValue, cp.value)
+
+            if cp_value is None:
+                return data
+            cond = (data[column] >= cp_value["min"]) & (data[column] <= cp_value["max"])
+            return data[cond]
+
+        self._dataSource.send_filter(cp.id, Filter(data_filter))
+
+    cp.on("change", onchange)
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp)
+        min, max = self._dataSource._idataSource.range_min_max(data, column)
+        if min is None or max is None:
+            cp.value = None
+        else:
+            new_value = cast(TQRangeValue, cp.value)
+            if new_value is not None:
+                new_value = new_value.copy()
+
+                if new_value["min"] < min:
+                    new_value["min"] = min
+                if new_value["max"] > max:
+                    new_value["max"] = max
+
+                cp.value = new_value
+                cp.update()
+
+    self._dataSource._register_component(cp.id, on_source_update)
+
+    return RangeResult(cp, self._dataSource, ref_value)

ex4nicegui/bi/elements/ui_select.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from nicegui import ui
+from ex4nicegui import to_ref, ref_computed
+from ex4nicegui.utils.signals import Ref
+from ex4nicegui.bi.dataSource import Filter
+from .models import UiResult
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade, DataSource
+
+
+class SelectResult(UiResult[ui.select]):
+    def __init__(
+        self,
+        element: ui.select,
+        dataSource: DataSource,
+        ref_value: Ref,
+    ) -> None:
+        super().__init__(element, dataSource)
+        self._ref_value = ref_value
+
+        @ref_computed
+        def value_or_options():
+            if not self._ref_value.value:
+                return self.element.options
+            return self._ref_value.value
+
+        self._value_or_options = value_or_options
+
+    @property
+    def value(self):
+        return self.get_value()
+
+    def get_value(self, no_select_eq_all=True):
+        """Get the selected items of the dropdown box
+
+        Args:
+            no_select_eq_all (bool, optional): When there is no selection, it is eq to selecting all. Defaults to True.
+        """
+        if no_select_eq_all:
+            return self._value_or_options.value
+
+        return self._ref_value.value
+
+
+def ui_select(
+    self: DataSourceFacade, column: str, *, clearable=True, multiple=True, **kwargs
+) -> SelectResult:
+    options = self._dataSource._idataSource.duplicates_column_values(self.data, column)
+    kwargs.update(
+        {
+            "options": options,
+            "multiple": multiple,
+            "clearable": clearable,
+            "label": column,
+        }
+    )
+
+    cp = ui.select(**kwargs).props("use-chips outlined").classes("min-w-[8rem]")
+    ref_value = to_ref(cp.value)
+
+    def onchange(e):
+        value = None
+        if e.args:
+            if isinstance(e.args, list):
+                value = [arg["label"] for arg in e.args]
+            else:
+                value = e.args["label"]
+
+        cp.value = value
+        ref_value.value = value  # type: ignore
+
+        def data_filter(data):
+            if cp.value is None or not cp.value:
+                return data
+
+            cond = None
+            if isinstance(cp.value, list):
+                cond = data[column].isin(cp.value)
+            else:
+                cond = data[column] == cp.value
+            return data[cond]
+
+        self._dataSource.send_filter(cp.id, Filter(data_filter))
+
+    cp.on("update:modelValue", onchange)
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp)
+        options = self._dataSource._idataSource.duplicates_column_values(data, column)
+        value = cp.value
+
+        # Make the value within the options
+        if isinstance(value, list):
+            value = list(set(value) & set(options))
+        else:
+            if value not in options:
+                value = ""
+
+        cp.set_options(options, value=value)
+
+    self._dataSource._register_component(cp.id, on_source_update)
+
+    return SelectResult(cp, self._dataSource, ref_value)

ex4nicegui/bi/elements/ui_slider.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING
+from nicegui import ui
+from ex4nicegui import to_ref
+from ex4nicegui.utils.signals import Ref
+from ex4nicegui.bi.dataSource import Filter
+from .models import UiResult
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade, DataSource
+
+
+class SliderResult(UiResult[ui.slider]):
+    def __init__(
+        self,
+        element: ui.slider,
+        dataSource: DataSource,
+        ref_value: Ref,
+    ) -> None:
+        super().__init__(element, dataSource)
+        self._ref_value = ref_value
+
+    @property
+    def value(self):
+        return self._ref_value.value
+
+
+def ui_slider(self: DataSourceFacade, column: str, **kwargs):
+    self._dataSource._idataSource.slider_check(self.data, column)
+
+    min, max = self._dataSource._idataSource.slider_min_max(self.data, column)
+    kwargs.update({"min": min, "max": max})
+
+    cp = ui.slider(**kwargs).props("label label-always switch-label-side")
+    ref_value = to_ref(cp.value)
+
+    def onchange():
+        def data_filter(data):
+            if cp.value is None or cp.value < min:
+                return data
+            cond = data[column] == cp.value
+            return data[cond]
+
+        self._dataSource.send_filter(cp.id, Filter(data_filter))
+
+    cp.on("change", onchange)
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp)
+        min, max = self._dataSource._idataSource.slider_min_max(data, column)
+        if min is None or max is None:
+            cp.value = None
+        else:
+            cp._props["min"] = min
+            cp._props["max"] = max
+
+    self._dataSource._register_component(cp.id, on_source_update)
+
+    return SliderResult(cp, self._dataSource, ref_value)

ex4nicegui/bi/protocols.py

@@ -1,5 +1,5 @@
 from typing_extensions import Protocol
-from typing import Callable, Dict, List, Optional, Tuple
+from typing import Any, Callable, Dict, List, Optional, Tuple
 
 from ex4nicegui.bi.types import _TFilterCallback
 from .types import _TFilterCallback
@@ -7,10 +7,10 @@ from ex4nicegui.utils import common as utils_common
 
 
 class IDataSourceAble(Protocol):
-    def get_data(self):
+    def get_data(self) -> Any:
         ...
 
-    def apply_filters(self, data, filters: List[_TFilterCallback]):
+    def apply_filters(self, data, filters: List[_TFilterCallback]) -> Any:
         ...
 
     def duplicates_column_values(self, data, column_name: str) -> List:
@@ -27,6 +27,14 @@ class IDataSourceAble(Protocol):
     ) -> Tuple[Optional[float], Optional[float]]:
         ...
 
+    def range_check(self, data, column_name: str) -> None:
+        ...
+
+    def range_min_max(
+        self, data, column_name: str
+    ) -> Tuple[Optional[float], Optional[float]]:
+        ...
+
 
 class DataFrameDataSourceAble(IDataSourceAble):
     def __init__(self, df) -> None:
@@ -70,6 +78,24 @@ class DataFrameDataSourceAble(IDataSourceAble):
 
         return min, max
 
+    def range_check(self, data, column_name: str) -> None:
+        from pandas.api.types import is_numeric_dtype
+
+        if not is_numeric_dtype(data[column_name]):
+            raise ValueError(f"column[{column_name}] must be numeric type")
+
+    def range_min_max(
+        self, data, column_name: str
+    ) -> Tuple[Optional[float], Optional[float]]:
+        import numpy as np
+
+        min, max = data[column_name].min(), data[column_name].max()
+
+        if np.isnan(min) or np.isnan(max):
+            return None, None
+
+        return min, max
+
 
 class CallableDataSourceAble(IDataSourceAble):
     def __init__(self, fn: Callable) -> None:
@@ -89,14 +115,17 @@ class CallableDataSourceAble(IDataSourceAble):
         return data[column_name].drop_duplicates().tolist()
 
     def get_aggrid_options(self, data) -> Dict:
-        df = data
+        df = utils_common.convert_dataframe(data)
         return {
             "columnDefs": [{"field": col} for col in df.columns],
             "rowData": df.to_dict("records"),
         }
 
     def slider_check(self, data, column_name: str) -> None:
-        pass
+        from pandas.api.types import is_numeric_dtype
+
+        if not is_numeric_dtype(data[column_name]):
+            raise ValueError(f"column[{column_name}] must be numeric type")
 
     def slider_min_max(
         self, data, column_name: str
@@ -109,3 +138,21 @@ class CallableDataSourceAble(IDataSourceAble):
             return None, None
 
         return min, max
+
+    def range_check(self, data, column_name: str) -> None:
+        from pandas.api.types import is_numeric_dtype
+
+        if not is_numeric_dtype(data[column_name]):
+            raise ValueError(f"column[{column_name}] must be numeric type")
+
+    def range_min_max(
+        self, data, column_name: str
+    ) -> Tuple[Optional[float], Optional[float]]:
+        import numpy as np
+
+        min, max = data[column_name].min(), data[column_name].max()
+
+        if np.isnan(min) or np.isnan(max):
+            return None, None
+
+        return min, max

ex4nicegui/bi/types.py

@@ -1,11 +1,12 @@
+from __future__ import annotations
 from typing import Callable, TypeVar
+from typing import TYPE_CHECKING
 
 
 _TData = TypeVar("_TData")
 
 _TElementID = int
 _TNgClientID = str
-_TComponentUpdateCallback = Callable[[_TData], None]
 _TFilterCallback = Callable[[_TData], _TData]
 
 _TDataSourceId = int

ex4nicegui/reactive/EChartsComponent/ECharts.py

@@ -55,6 +55,7 @@ class echarts(Element, component="ECharts.js"):
             [open echarts setOption docs](https://echarts.apache.org/zh/api.html#echartsInstance.setOption)
 
         """
+        self._props["options"] = options
         self.run_method("updateOptions", options, opts)
         self.update()
         return self

ex4nicegui/reactive/officials/base.py

@@ -29,7 +29,7 @@ from nicegui.elements.mixins.text_element import TextElement
 
 T = TypeVar("T")
 
-TWidget = TypeVar("TWidget")
+TWidget = TypeVar("TWidget", bound=ui.element)
 
 
 class BindableUi(Generic[TWidget]):
@@ -61,6 +61,13 @@ class BindableUi(Generic[TWidget]):
         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
@@ -78,6 +85,10 @@ class BindableUi(Generic[TWidget]):
     def element(self):
         return self.__element
 
+    def delete(self) -> None:
+        """Delete the element."""
+        self.element.delete()
+
     def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
         if prop == "visible":
             return self.bind_visible(ref_ui)

ex4nicegui/reactive/officials/button.py

@@ -57,7 +57,7 @@ class ButtonBindableUi(SingleValueBindableUi[str, ui.button]):
         @effect
         def _():
             ele = self.element
-            ele._props["text"] = ref_ui.value
+            ele._props["label"] = ref_ui.value
             ele.update()
 
         return self

ex4nicegui/reactive/officials/drawer.py

@@ -51,8 +51,7 @@ class DrawerBindableUi(SingleValueBindableUi[bool, Drawer]):
         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")
+        element.classes("flex flex-col gap-4 backdrop-blur-md bg-[#5898d4]/30")
 
         init_value = (
             element._props["model-value"]