ex4nicegui 0.3.0__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.3.0"
+__version__ = "0.3.1"

ex4nicegui/bi/__init__.py

@@ -1,3 +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"]
+__all__ = [
+    "data_source",
+    "ui_left_drawer",
+    "ui_title",
+    "ui_header",
+    "ui_subheader",
+    "ui_cols",
+]

ex4nicegui/bi/dataSource.py

@@ -1,16 +1,12 @@
-from typing import Dict, List, Optional, cast
+from typing import Callable, Dict, List, Optional, Set, cast
 from ex4nicegui import to_ref, ref_computed, on
-from nicegui import globals, Client
+from nicegui import globals as ng_globals, Client, ui
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from . import types
 from .protocols import IDataSourceAble
 
-
-@dataclass
-class DataSourceInfo:
-    source: "DataSource"
-    update_callback: types._TSourceBuildFn
+_TComponentUpdateCallback = Callable[[], None]
 
 
 @dataclass
@@ -27,8 +23,12 @@ class ComponentInfoKey:
 @dataclass
 class ComponentInfo:
     key: ComponentInfoKey
-    update_callback: types._TComponentUpdateCallback
+    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:
@@ -56,9 +56,10 @@ class ComponentMap:
         if client_id in self._client_map:
             del self._client_map[client_id]
 
-    def has_record(self, client_id: types._TNgClientID, element_id: types._TElementID):
+    def has_record(self, key: ComponentInfoKey):
         return (
-            client_id in self._client_map and element_id in self._client_map[client_id]
+            key.client_id in self._client_map
+            and key.element_id in self._client_map[key.client_id]
         )
 
     def set_filter(
@@ -74,6 +75,9 @@ class ComponentMap:
             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
@@ -118,12 +122,33 @@ class DataSource:
     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: types._TComponentUpdateCallback,
+        update_callback: Optional[_TComponentUpdateCallback] = None,
     ):
-        ng_client = globals.get_client()
+        ng_client = ng_globals.get_client()
         client_id = ng_client.id
 
         if not self._component_map.has_client_record(client_id):
@@ -133,42 +158,46 @@ class DataSource:
                 if not e.shared:
                     self._component_map.remove_client(e.id)
 
-        self._component_map.add_info(
-            ComponentInfo(ComponentInfoKey(client_id, element_id), update_callback)
-        )
+        info = ComponentInfo(ComponentInfoKey(client_id, element_id), update_callback)
+        self._component_map.add_info(info)
 
-        return self
+        return info
 
     def send_filter(self, element_id: types._TElementID, filter: Filter):
-        client_id = globals.get_client().id
+        client_id = ng_globals.get_client().id
+        key = ComponentInfoKey(client_id, element_id)
 
-        if not self._component_map.has_record(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)
 
-        self.__notify_update([ComponentInfoKey(client_id, element_id)])
-        return self
+        trigger_info = self._component_map.get_info(
+            ComponentInfoKey(client_id, element_id)
+        )
 
-    def __notify_update(self, ignore_keys: Optional[List[ComponentInfoKey]] = None):
-        ignore_keys = ignore_keys or []
-        ignore_ids_set = set(ignore_keys)
+        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():
-            if current_info.key in ignore_ids_set:
+            # not nodify the self triggering
+            if trigger_info and current_info.key == trigger_info.key:
                 continue
 
-            # apply filters ,except current target
-            filters = [
-                info.filter.callback
-                for info in self._component_map.get_all_info()
-                if (info.key != current_info.key) and info.filter
-            ]
-
-            new_data = self._idataSource.apply_filters(self.__data.value, filters)
-            current_info.update_callback(new_data)
+            update_callback = current_info.update_callback
+            if update_callback:
+                update_callback()
 
-        self.__filters.value = [
-            info.filter for info in self._component_map.get_all_info() if info.filter
-        ]
+    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

@@ -1,10 +1,14 @@
 from __future__ import annotations
 from typing import Any, Callable, Dict, TypeVar, Generic, Union, cast
 from nicegui import ui
-from ex4nicegui import ref_computed
-from ex4nicegui.reactive import rxui
 from .dataSource import DataSource, Filter
-from ex4nicegui.reactive.EChartsComponent.ECharts import echarts
+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")
@@ -24,9 +28,7 @@ class DataSourceFacade(Generic[_TData]):
         """Data after filtering"""
         return cast(_TData, self._dataSource.filtered_data)
 
-    def ui_select(
-        self, column: str, *, clearable=True, multiple=True, **kwargs
-    ) -> ui.select:
+    def ui_select(self, column: str, *, clearable=True, multiple=True, **kwargs):
         """
         Creates a user interface select box.
 
@@ -37,65 +39,11 @@ class DataSourceFacade(Generic[_TData]):
             **kwargs: Additional optional parameters that will be passed to the ui.select constructor.
 
         Returns:
-            ui.select: An instance of a user interface select box.
+            SelectResult: An instance of a user interface select box.
         """
-        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")
-
-        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
-
-            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):
-            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 cp
+        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):
         """
@@ -107,23 +55,7 @@ class DataSourceFacade(Generic[_TData]):
         Returns:
             ui.aggrid: aggrid table.
         """
-        kwargs.update(
-            {"options": self._dataSource._idataSource.get_aggrid_options(self.data)}
-        )
-
-        cp = ui.aggrid(**kwargs)
-
-        def on_source_update(data):
-            cp._props["options"] = self._dataSource._idataSource.get_aggrid_options(
-                data
-            )
-            cp.update()
-
-        on_source_update(self.filtered_data)
-
-        self._dataSource._register_component(cp.id, on_source_update)
-
-        return cp
+        return ui_aggrid(self, **kwargs)
 
     def ui_radio(self, column: str, **kwargs):
         """
@@ -134,41 +66,11 @@ class DataSourceFacade(Generic[_TData]):
             **kwargs: Additional optional parameters that will be passed to the ui.radio constructor.
 
         Returns:
-            ui.radio: An radio Selection.
+            RadioResult: An radio Selection.
         """
-        options = self._dataSource._idataSource.duplicates_column_values(
-            self.data, column
-        )
-        kwargs.update({"options": options})
-
-        cp = ui.radio(**kwargs)
-
-        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):
-            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 cp
+        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):
         """
@@ -181,39 +83,28 @@ class DataSourceFacade(Generic[_TData]):
         Returns:
             ui.radio: An Slider.
         """
-        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")
-
-        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]
+        kws = {key: value for key, value in locals().items() if key not in ("kwargs")}
+        kws.update(kwargs)
+        return ui_slider(**kws)
 
-            self._dataSource.send_filter(cp.id, Filter(data_filter))
-
-        cp.on("change", onchange)
-
-        def on_source_update(data):
-            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
+    def ui_range(self, column: str, **kwargs):
+        """
+        Creates Range.
 
-        self._dataSource._register_component(cp.id, on_source_update)
+        Parameters:
+            column (str): The column name of the data source.
+            **kwargs: Additional optional parameters that will be passed to the ui.slider constructor.
 
-        return cp
+        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
-    ) -> echarts:
+    ):
         """Create charts
 
         Args:
@@ -245,19 +136,13 @@ class DataSourceFacade(Generic[_TData]):
         ```
 
         """
-
-        @ref_computed
-        def chart_options():
-            options = fn(self.filtered_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()))
-
-        cp = rxui.echarts(chart_options)  # type: ignore
-
-        return cp.element  # type: ignore
+        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: {
+
+    },
+};