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

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/index.py

@@ -0,0 +1,76 @@
+from .dataSourceFacade import DataSourceFacade
+from .dataSource import DataSource
+from .protocols import CallableDataSourceAble, DataFrameDataSourceAble
+from typing import Callable, cast, TypeVar, Union
+
+
+_TData = TypeVar("_TData")
+
+
+def data_source(data: Union[Callable[..., _TData], _TData]) -> DataSourceFacade[_TData]:
+    """Create a data source
+
+    Args:
+        data (_TData): Any supported data
+
+    Raises:
+        TypeError: Throw an error when the data type is not supported
+
+    Returns:
+        DataSourceFacade[_TData]: _description_
+
+    ## Examples
+
+    ---
+
+    pandas dataframe source:
+    ```python
+    df = pd.DataFrame({"name": list("abcdc"), "value": range(5)})
+    ds = bi.data_source(df)
+    ```
+
+    ---
+
+    Link multiple data sources
+
+    ---
+    ```python
+    df = pd.DataFrame({"name": list("abcdc"), "value": range(5)})
+    ds = bi.data_source(df)
+
+    @bi.data_source
+    def ds_other():
+        #  ds.filtered_data is DataFrame after filtering
+        where = ds.filtered_data[''].isin(['b','c','d'])
+        return ds.filtered_data[where]
+
+    ```
+
+    ---
+
+    Now, when `ds` changes, it will trigger changes to `ds_other` and thus drive the related interface components to change.
+
+    ```python
+    # select box of data source 'ds'
+    # it change will trigger changes to table
+    ds.ui_select('name')
+
+    # table of data 'ds_other'
+    ds_other.ui_aggrid()
+    ```
+
+
+    """
+    ds_protocol = None
+
+    if type(data).__name__ == "DataFrame":
+        ds_protocol = DataFrameDataSourceAble(data)
+
+    if isinstance(data, Callable):
+        ds_protocol = CallableDataSourceAble(data)
+
+    if ds_protocol is None:
+        raise TypeError(f"not support type[{type(data)}]")
+
+    ds = DataSource(ds_protocol)
+    return cast(DataSourceFacade[_TData], DataSourceFacade(ds))

ex4nicegui/bi/protocols.py

@@ -0,0 +1,158 @@
+from typing_extensions import Protocol
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from ex4nicegui.bi.types import _TFilterCallback
+from .types import _TFilterCallback
+from ex4nicegui.utils import common as utils_common
+
+
+class IDataSourceAble(Protocol):
+    def get_data(self) -> Any:
+        ...
+
+    def apply_filters(self, data, filters: List[_TFilterCallback]) -> Any:
+        ...
+
+    def duplicates_column_values(self, data, column_name: str) -> List:
+        ...
+
+    def get_aggrid_options(self, data) -> Dict:
+        ...
+
+    def slider_check(self, data, column_name: str) -> None:
+        ...
+
+    def slider_min_max(
+        self, data, column_name: str
+    ) -> 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:
+        self.data = df
+
+    def get_data(self):
+        return self.data
+
+    def apply_filters(self, data, filters: List[_TFilterCallback]):
+        new_data = data
+        for f in filters:
+            new_data = f(new_data)
+
+        return new_data
+
+    def duplicates_column_values(self, data, column_name: str) -> List:
+        return data[column_name].drop_duplicates().tolist()
+
+    def get_aggrid_options(self, data) -> Dict:
+        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:
+        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
+    ) -> 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
+
+    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:
+        self.data_fn = fn
+
+    def get_data(self):
+        return self.data_fn()
+
+    def apply_filters(self, data, filters: List[_TFilterCallback]):
+        new_data = data
+        for f in filters:
+            new_data = f(new_data)
+
+        return new_data
+
+    def duplicates_column_values(self, data, column_name: str) -> List:
+        return data[column_name].drop_duplicates().tolist()
+
+    def get_aggrid_options(self, data) -> Dict:
+        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:
+        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
+    ) -> 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
+
+    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

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from typing import Callable, TypeVar
+from typing import TYPE_CHECKING
+
+
+_TData = TypeVar("_TData")
+
+_TElementID = int
+_TNgClientID = str
+_TFilterCallback = Callable[[_TData], _TData]
+
+_TDataSourceId = int
+_TSourceBuildFn = Callable[..., _TData]

ex4nicegui/reactive/EChartsComponent/ECharts.js

@@ -43967,8 +43967,7 @@ const TX = { class: "echart-container relative" }, CX = /* @__PURE__ */ GL({
         l.target || t("chartClickBlank");
       });
       function s() {
-        const l = n.value.getBoundingClientRect();
-        i == null || i.resize({ width: l.width - 5, height: l.height - 5 });
+        i == null || i.resize();
       }
       ZL("resize", () => {
         s();

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