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

ex4nicegui/__init__.py

@@ -16,4 +16,4 @@ from signe import batch
 from ex4nicegui.experimental_ import gridLayout as exp_ui
 
 
-__version__ = "0.2.18"
+__version__ = "0.3.1"

ex4nicegui/bi/__init__.py

@@ -0,0 +1,13 @@
+from .index import data_source
+from .elements.text import ui_title, ui_header, ui_subheader
+from .elements.containers import ui_cols
+from .elements.layouts import ui_left_drawer
+
+__all__ = [
+    "data_source",
+    "ui_left_drawer",
+    "ui_title",
+    "ui_header",
+    "ui_subheader",
+    "ui_cols",
+]

ex4nicegui/bi/dataSource.py

@@ -0,0 +1,203 @@
+from typing import Callable, Dict, List, Optional, Set, cast
+from ex4nicegui import to_ref, ref_computed, on
+from nicegui import globals as ng_globals, Client, ui
+
+from dataclasses import dataclass, field
+from . import types
+from .protocols import IDataSourceAble
+
+_TComponentUpdateCallback = Callable[[], None]
+
+
+@dataclass
+class Filter:
+    callback: types._TFilterCallback
+
+
+@dataclass(frozen=True)
+class ComponentInfoKey:
+    client_id: types._TNgClientID
+    element_id: types._TElementID
+
+
+@dataclass
+class ComponentInfo:
+    key: ComponentInfoKey
+    update_callback: Optional[_TComponentUpdateCallback] = None
+    filter: Optional[Filter] = None
+    exclude_keys: Set[ComponentInfoKey] = field(default_factory=set)
+
+    def __eq__(self, other):
+        return isinstance(other, ComponentInfo) and self.key == other.key
+
+
+class ComponentMap:
+    def __init__(self) -> None:
+        self._client_map: Dict[
+            types._TNgClientID, Dict[types._TElementID, ComponentInfo]
+        ] = {}
+
+    def has_client_record(self, client_id: types._TNgClientID):
+        return client_id in self._client_map
+
+    def add_info(self, info: ComponentInfo):
+        client_id = info.key.client_id
+        element_id = info.key.element_id
+
+        if client_id not in self._client_map:
+            self._client_map[client_id] = {element_id: info}
+
+        element_map = self._client_map[client_id]
+
+        if element_id not in element_map:
+            element_map[element_id] = info
+
+    def remove_client(self, client_id: types._TNgClientID):
+        if client_id in self._client_map:
+            del self._client_map[client_id]
+
+    def has_record(self, key: ComponentInfoKey):
+        return (
+            key.client_id in self._client_map
+            and key.element_id in self._client_map[key.client_id]
+        )
+
+    def set_filter(
+        self,
+        client_id: types._TNgClientID,
+        element_id: types._TElementID,
+        filter: Filter,
+    ):
+        self._client_map[client_id][element_id].filter = filter
+
+    def get_all_info(self):
+        return (
+            info for ele_map in self._client_map.values() for info in ele_map.values()
+        )
+
+    def get_info(self, key: ComponentInfoKey) -> ComponentInfo:
+        return self._client_map[key.client_id][key.element_id]
+
+
+class DataSource:
+    _global_id_count: types._TDataSourceId = 0
+
+    def __init__(self, data: IDataSourceAble) -> None:
+        DataSource._global_id_count += 1
+        self.__id = DataSource._global_id_count
+
+        self._idataSource = data
+
+        data_fn = lambda: data.get_data()
+        data_fn = ref_computed(data_fn)
+
+        self.__filters = to_ref(cast(List[Filter], []))
+
+        @ref_computed
+        def apply_filters():
+            df = data_fn.value
+            for f in self.__filters.value:
+                df = f.callback(df)
+
+            return df
+
+        self.__filtered_data = apply_filters
+
+        self.__data = data_fn
+        self._component_map = ComponentMap()
+
+        @on(data_fn)
+        def _():
+            self.__notify_update()
+
+    @property
+    def data(self):
+        return self.__data.value
+
+    @property
+    def filtered_data(self):
+        return self.__filtered_data.value
+
+    @property
+    def id(self):
+        return self.__id
+
+    def get_component_info_key(self, element_id: types._TElementID):
+        client_id = ng_globals.get_client().id
+        return ComponentInfoKey(client_id, element_id)
+
+    def get_filtered_data(self, element: ui.element):
+        data = self._idataSource.get_data()
+
+        # note:must be use client id of the element
+        key = ComponentInfoKey(element.client.id, element.id)
+        current_info = self._component_map.get_info(key)
+
+        filters = [
+            info.filter.callback
+            for info in self._component_map.get_all_info()
+            if current_info.key != info.key
+            and (info.key not in current_info.exclude_keys)
+            and info.filter
+        ]
+
+        return self._idataSource.apply_filters(data, filters)
+
+    def _register_component(
+        self,
+        element_id: types._TElementID,
+        update_callback: Optional[_TComponentUpdateCallback] = None,
+    ):
+        ng_client = ng_globals.get_client()
+        client_id = ng_client.id
+
+        if not self._component_map.has_client_record(client_id):
+
+            @ng_client.on_disconnect
+            def _(e: Client):
+                if not e.shared:
+                    self._component_map.remove_client(e.id)
+
+        info = ComponentInfo(ComponentInfoKey(client_id, element_id), update_callback)
+        self._component_map.add_info(info)
+
+        return info
+
+    def send_filter(self, element_id: types._TElementID, filter: Filter):
+        client_id = ng_globals.get_client().id
+        key = ComponentInfoKey(client_id, element_id)
+
+        if not self._component_map.has_record(key):
+            raise ValueError("element not register")
+
+        self._component_map.set_filter(client_id, element_id, filter)
+
+        trigger_info = self._component_map.get_info(
+            ComponentInfoKey(client_id, element_id)
+        )
+
+        self.__notify_update(trigger_info)
+        self.__filters.value = [
+            info.filter for info in self._component_map.get_all_info() if info.filter
+        ]
+
+        return self
+
+    def __notify_update(self, trigger_info: Optional[ComponentInfo] = None):
+        # nodify every component
+        for current_info in self._component_map.get_all_info():
+            # not nodify the self triggering
+            if trigger_info and current_info.key == trigger_info.key:
+                continue
+
+            update_callback = current_info.update_callback
+            if update_callback:
+                update_callback()
+
+    def on_source_update(
+        self,
+        element_id: types._TElementID,
+        callback: _TComponentUpdateCallback,
+    ):
+        key = self.get_component_info_key(element_id)
+        self._component_map.get_info(key).update_callback = callback

ex4nicegui/bi/dataSourceFacade.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+from typing import Any, Callable, Dict, TypeVar, Generic, Union, cast
+from nicegui import ui
+from .dataSource import DataSource, Filter
+from . import types as bi_types
+from .elements.ui_select import ui_select
+from .elements.ui_radio import ui_radio
+from .elements.ui_slider import ui_slider
+from .elements.ui_range import ui_range
+from .elements.ui_echarts import ui_echarts
+from .elements.ui_aggrid import ui_aggrid
+
+
+_TData = TypeVar("_TData")
+
+
+class DataSourceFacade(Generic[_TData]):
+    def __init__(self, ds: DataSource) -> None:
+        self._dataSource = ds
+
+    @property
+    def data(self) -> _TData:
+        """Data without any filtering"""
+        return cast(_TData, self._dataSource.data)
+
+    @property
+    def filtered_data(self) -> _TData:
+        """Data after filtering"""
+        return cast(_TData, self._dataSource.filtered_data)
+
+    def ui_select(self, column: str, *, clearable=True, multiple=True, **kwargs):
+        """
+        Creates a user interface select box.
+
+        Parameters:
+            column (str): The column name of the data source.
+            clearable (bool, optional): Whether to allow clearing the content of the select box. Default is True.
+            multiple (bool, optional): Whether to allow multiple selections.
+            **kwargs: Additional optional parameters that will be passed to the ui.select constructor.
+
+        Returns:
+            SelectResult: An instance of a user interface select box.
+        """
+        kws = {key: value for key, value in locals().items() if key not in ("kwargs")}
+        kws.update(kwargs)
+        return ui_select(**kws)
+
+    def ui_aggrid(self, **kwargs):
+        """
+        Creates aggrid table.
+
+        Parameters:
+            **kwargs: Additional optional parameters that will be passed to the ui.aggrid constructor.
+
+        Returns:
+            ui.aggrid: aggrid table.
+        """
+        return ui_aggrid(self, **kwargs)
+
+    def ui_radio(self, column: str, **kwargs):
+        """
+        Creates radio Selection.
+
+        Parameters:
+            column (str): The column name of the data source.
+            **kwargs: Additional optional parameters that will be passed to the ui.radio constructor.
+
+        Returns:
+            RadioResult: An radio Selection.
+        """
+        kws = {key: value for key, value in locals().items() if key not in ("kwargs")}
+        kws.update(kwargs)
+        return ui_radio(**kws)
+
+    def ui_slider(self, column: str, **kwargs):
+        """
+        Creates Slider.
+
+        Parameters:
+            column (str): The column name of the data source.
+            **kwargs: Additional optional parameters that will be passed to the ui.slider constructor.
+
+        Returns:
+            ui.radio: An Slider.
+        """
+        kws = {key: value for key, value in locals().items() if key not in ("kwargs")}
+        kws.update(kwargs)
+        return ui_slider(**kws)
+
+    def ui_range(self, column: str, **kwargs):
+        """
+        Creates Range.
+
+        Parameters:
+            column (str): The column name of the data source.
+            **kwargs: Additional optional parameters that will be passed to the ui.slider constructor.
+
+        Returns:
+            QRange: An Range.
+        """
+        kws = {key: value for key, value in locals().items() if key not in ("kwargs")}
+        kws.update(kwargs)
+        return ui_range(**kws)
+
+    def ui_echarts(
+        self, fn: Callable[[Any], Union[Dict, "pyecharts.Base"]]  # pyright: ignore
+    ):
+        """Create charts
+
+        Args:
+            fn (Callable[[Any], Union[Dict, "pyecharts.Base"]]): builder function.
+
+        ## Examples
+
+        Support pyecharts
+
+        ```py
+        import pandas as pd
+        from ex4nicegui import bi
+        from pyecharts.charts import Bar
+
+        df = pd.DataFrame({"name": list("abcdc"), "value": range(5)})
+        ds = bi.data_source(df)
+
+        @ds.ui_echarts
+        def bar(data: pd.DataFrame):
+            c = (
+                Bar()
+                .add_xaxis(data["name"].tolist())
+                .add_yaxis("value", data["value"].tolist())
+            )
+
+            return c
+
+        bar.classes("h-[20rem]")
+        ```
+
+        """
+        return ui_echarts(self, fn)
+
+    def send_filter(
+        self, element: ui.element, filter: bi_types._TFilterCallback[_TData]
+    ):
+        ele_id = element.id
+        key = self._dataSource.get_component_info_key(ele_id)
+        if not self._dataSource._component_map.has_record(key):
+            self._dataSource._register_component(ele_id)
+        self._dataSource.send_filter(ele_id, Filter(filter))

ex4nicegui/bi/elements/containers.py

@@ -0,0 +1,13 @@
+from nicegui import ui
+from ex4nicegui.layout import grid_box
+
+
+def ui_cols(num: int, min_width="0"):
+    with grid_box(template_columns=f"repeat({num},1fr)").classes(
+        "justify-between"
+    ) as gb:
+        divs = [ui.column() for _ in range(num)]
+
+    gb.grid_box(template_columns="1fr", break_point="<sm[0-599.99px]")
+
+    return divs

ex4nicegui/bi/elements/layouts.py

@@ -0,0 +1,28 @@
+from nicegui import ui
+from ex4nicegui.reactive import rxui
+from ex4nicegui import to_ref
+
+
+def ui_left_drawer():
+    drawer_show = to_ref(True)
+
+    with rxui.drawer("left", value=drawer_show) as drawer:
+        with ui.page_sticky("top-right", x_offset=10, y_offset=10):
+            icon_close = (
+                rxui.icon(name="close")
+                .classes("cursor-pointer")
+                .props("round ")
+                .bind_visible(drawer_show)
+            )
+            icon_close.on("click", drawer.toggle)
+
+    with ui.page_sticky("top-left", x_offset=10, y_offset=10):
+        icon_close = (
+            rxui.icon(name="keyboard_arrow_right", size="1.2rem")
+            .classes("cursor-pointer")
+            .props("round ")
+            .bind_not_visible(drawer_show)
+        )
+        icon_close.on("click", drawer.toggle)
+
+    return drawer.element

ex4nicegui/bi/elements/models.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+from typing import Optional, TypeVar, Generic, TYPE_CHECKING, Union
+from nicegui import ui
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSource import DataSource
+
+
+_T_ELEMENT = TypeVar("_T_ELEMENT", bound=ui.element)
+
+
+class UiResult(Generic[_T_ELEMENT]):
+    def __init__(self, element: _T_ELEMENT, dataSource: "DataSource") -> None:
+        self.__element = element
+        self._dataSource = dataSource
+
+    @property
+    def element(self):
+        return self.__element
+
+    @property
+    def id(self):
+        return self.element.id
+
+    def classes(
+        self,
+        add: Optional[str] = None,
+        *,
+        remove: Optional[str] = None,
+        replace: Optional[str] = None,
+    ):
+        self.element.classes(add, remove=remove, replace=replace)
+        return self
+
+    def props(
+        self,
+        add: Optional[str] = None,
+        *,
+        remove: Optional[str] = None,
+    ):
+        self.element.props(add, remove=remove)
+        return self
+
+    def cancel_linkage(self, *source: Union[ui.element, "UiResult"]):
+        get_info_key = self._dataSource.get_component_info_key
+
+        key = get_info_key(self.element.id)
+
+        info = self._dataSource._component_map.get_info(key)
+
+        for s in source:
+            res_key = get_info_key(s.id)
+            info.exclude_keys.add(res_key)
+
+        return self

ex4nicegui/bi/elements/text.py

@@ -0,0 +1,33 @@
+from typing import Callable, Any, Union
+from nicegui import ui
+from ex4nicegui import effect
+
+
+_T_Maybe_Callable = Any
+
+
+def _ui_label(text_or_build: _T_Maybe_Callable):
+    label = ui.label()
+
+    if isinstance(text_or_build, Callable):
+
+        @effect
+        def _():
+            label.text = text_or_build()
+
+    else:
+        label.text = str(text_or_build)
+
+    return label
+
+
+def ui_title(text_or_build: _T_Maybe_Callable):
+    return _ui_label(text_or_build).style("font-size: calc(1.4rem + 1.8vw)")
+
+
+def ui_header(text_or_build: _T_Maybe_Callable):
+    return _ui_label(text_or_build).style("font-size: calc(1.35rem + 1.2vw)")
+
+
+def ui_subheader(text_or_build: _T_Maybe_Callable):
+    return _ui_label(text_or_build).style("font-size: calc(1.3rem + .6vw)")

ex4nicegui/bi/elements/ui_aggrid.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Union, cast
+from nicegui import ui
+from nicegui.events import UiEventArguments
+from ex4nicegui.reactive import rxui
+from ex4nicegui.reactive.EChartsComponent.ECharts import (
+    EChartsClickEventArguments,
+    echarts,
+)
+from ex4nicegui.bi.dataSource import DataSource
+from .models import UiResult
+
+if TYPE_CHECKING:
+    from ex4nicegui.bi.dataSourceFacade import DataSourceFacade
+
+
+class AggridResult(UiResult[ui.aggrid]):
+    def __init__(
+        self, element: ui.aggrid, dataSource: DataSource, table_update: Callable
+    ) -> None:
+        super().__init__(element, dataSource)
+        self.table_update = table_update
+
+    def cancel_linkage(self, *source: Union[ui.element, "UiResult"]):
+        super().cancel_linkage(*source)
+        self.table_update()
+
+
+def ui_aggrid(
+    self: DataSourceFacade,
+    **kwargs,
+):
+    kwargs.update({"options": {}})
+
+    cp = ui.aggrid(**kwargs)
+
+    def on_source_update():
+        data = self._dataSource.get_filtered_data(cp)
+        cp._props["options"] = self._dataSource._idataSource.get_aggrid_options(data)
+        cp.update()
+
+    info = self._dataSource._register_component(cp.id, on_source_update)
+
+    on_source_update()
+
+    return AggridResult(cp, self._dataSource, on_source_update)

ex4nicegui/bi/elements/ui_date_picker.js

@@ -0,0 +1,35 @@
+export default {
+    template: `
+        <div :id="'cus-'+id" class="q-pa-md" style="max-width: 300px">
+        <q-input filled v-model="value" mask="date" :rules="['date']">
+        <template v-slot:append>
+            <q-icon name="event" class="cursor-pointer">
+            <q-popup-proxy cover transition-show="scale" transition-hide="scale">
+                <q-date v-model="value" >
+                </q-date>
+            </q-popup-proxy>
+            </q-icon>
+        </template>
+        </q-input>
+    </div>
+    `,
+    props: {
+        id: String,
+        date: String,
+    },
+    data() {
+        return {
+            value: this.date
+        }
+    },
+    watch: {
+        value(newValue) {
+            this.$emit("update:value", newValue);
+        },
+    },
+    computed: {
+    },
+    methods: {
+
+    },
+};

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)