ex4nicegui 0.6.1__tar.gz → 0.6.3__tar.gz

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ex4nicegui
-Version: 0.6.1
+Version: 0.6.3
 Summary: Extension library based on nicegui, providing data responsive,BI functionality modules
 Home-page: 
 Author: carson_jia

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/ex4nicegui/__init__.py

@@ -45,4 +45,4 @@ __all__ = [
     "is_setter_ref",
 ]
 
-__version__ = "0.6.1"
+__version__ = "0.6.3"

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/ex4nicegui/reactive/__init__.py

@@ -1,4 +1,4 @@
-from .officials.aggrid import AggridBindableUi as aggird
+from .officials.aggrid import AggridBindableUi as aggrid
 from .officials.button import ButtonBindableUi as button
 from .officials.card import (
     CardBindableUi as card,
@@ -46,6 +46,10 @@ from .officials.expansion import ExpansionBindableUi as expansion
 from .officials.linear_progress import LinearProgressBindableUi as linear_progress
 from .officials.knob import KnobBindableUi as knob
 from .officials.circular_progress import CircularProgressBindableUi as circular_progress
+from .officials.tabs import TabsBindableUi as tabs
+from .officials.tab import TabBindableUi as tab
+from .officials.tab_panels import TabPanelsBindableUi as tab_panels
+from .officials.tab_panel import TabPanelBindableUi as tab_panel
 from .q_pagination import PaginationBindableUi as q_pagination
 
 from .local_file_picker import local_file_picker
@@ -63,6 +67,10 @@ pagination = q_pagination
 
 
 __all__ = [
+    "tab_panels",
+    "tab_panel",
+    "tabs",
+    "tab",
     "circular_progress",
     "knob",
     "UploadResult",
@@ -76,7 +84,7 @@ __all__ = [
     "VforStore",
     "vmodel",
     "html",
-    "aggird",
+    "aggrid",
     "button",
     "card",
     "card_actions",

ex4nicegui-0.6.3/ex4nicegui/reactive/empty.js

@@ -0,0 +1,3 @@
+export default {
+    template: '<slot></slot>'
+}

ex4nicegui-0.6.3/ex4nicegui/reactive/empty.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+from nicegui.element import Element
+
+
+class Empty(Element, component="empty.js"):
+    pass

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/ex4nicegui/reactive/officials/aggrid.py

@@ -15,7 +15,7 @@ from ex4nicegui.utils.signals import (
 from ex4nicegui.utils.apiEffect import ui_effect
 from nicegui import ui
 from .base import BindableUi
-from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.reactive.utils import ParameterClassifier, dataframe2col_str
 
 
 class AggridBindableUi(BindableUi[ui.aggrid]):
@@ -48,32 +48,35 @@ class AggridBindableUi(BindableUi[ui.aggrid]):
             for col in df.columns  # type: ignore
         ]
 
-    @staticmethod
+    @classmethod
     def from_pandas(
+        cls,
         df: TMaybeRef,
         columns_define_fn: Optional[Callable[[str], Dict]] = None,
         **org_kws,
     ):
         columns_define_fn = columns_define_fn or (lambda x: {})
-        if is_ref(df):
+        if is_ref(df) or isinstance(df, Callable):
 
             @ref_computed
             def cp_options():
+                copy_df = dataframe2col_str(to_value(df))
                 columnDefs = AggridBindableUi._get_columnDefs_from_dataframe(
-                    df.value, columns_define_fn
+                    copy_df, columns_define_fn
                 )
-                rowData = df.value.to_dict("records")
+                rowData = copy_df.to_dict("records")
                 data = {"columnDefs": columnDefs, "rowData": rowData}
                 return data
 
-            return AggridBindableUi(cp_options, **org_kws)
+            return cls(cp_options, **org_kws)
 
+        copy_df = dataframe2col_str(df)
         columnDefs = AggridBindableUi._get_columnDefs_from_dataframe(
-            df, columns_define_fn
+            copy_df, columns_define_fn
         )
-        rowData = df.to_dict("records")  # type: ignore
+        rowData = copy_df.to_dict("records")  # type: ignore
         options = {"columnDefs": columnDefs, "rowData": rowData}
-        return AggridBindableUi(options, **org_kws)
+        return cls(options, **org_kws)
 
     def bind_prop(self, prop: str, ref_ui: ReadonlyRef[Any]):
         if prop == "options":

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/ex4nicegui/reactive/officials/base.py

@@ -224,7 +224,7 @@ class BindableUi(Generic[TWidget]):
 
         return self
 
-    def bind_style(self, style: Dict[str, TGetterOrReadonlyRef[str]]):
+    def bind_style(self, style: Dict[str, TGetterOrReadonlyRef[Any]]):
         """data binding is manipulating an element's style
 
         @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#bind-style
@@ -239,11 +239,15 @@ class BindableUi(Generic[TWidget]):
 
                     @self._ui_effect
                     def _(name=name, ref_obj=ref_obj):
-                        self.element._style[name] = to_value(ref_obj)
+                        self.element._style[name] = str(to_value(ref_obj))
                         self.element.update()
 
         return self
 
+    def update(self):
+        """Update the element on the client side."""
+        self.element.update()
+
 
 # class SingleValueBindableUi(BindableUi[TWidget], Generic[T, TWidget]):
 #     def __init__(self, value: TMaybeRef[T], element: TWidget) -> None:

ex4nicegui-0.6.3/ex4nicegui/reactive/officials/tab.py

@@ -0,0 +1,57 @@
+from typing import Dict, Optional
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    to_value,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import BindableUi
+
+
+class TabBindableUi(BindableUi[ui.tab]):
+    def __init__(
+        self,
+        name: TMaybeRef[str],
+        label: Optional[TMaybeRef[str]] = None,
+        icon: Optional[TMaybeRef[str]] = None,
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=["name", "label", "icon"],
+        )
+
+        value_kws = pc.get_values_kws()
+        element = ui.tab(**value_kws)
+        super().__init__(element)
+
+        bindings_kws = pc.get_bindings()
+        self.__bind_label(bindings_kws, value_kws)
+
+        if "label" in bindings_kws:
+            bindings_kws.pop("label")
+
+        for key, value in bindings_kws.items():
+            self.bind_prop(key, value)  # type: ignore
+
+    # def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+    #     if prop == "name":
+    #         return self.bind_name(ref_ui)
+
+    #     return super().bind_prop(prop, ref_ui)
+
+    def __bind_label(self, binding_kws: Dict, value_kws: Dict):
+        name_ref = binding_kws.get("name") or value_kws.get("name")
+        label_ref = binding_kws.get("label") or value_kws.get("label")
+
+        @self._ui_effect
+        def _():
+            self.element._props["label"] = (
+                to_value(label_ref) if label_ref is not None else to_value(name_ref)
+            )
+            self.element.update()
+
+    # def bind_name(self, ref_ui: TMaybeRef):
+    #     @self._ui_effect
+    #     def _():
+    #         self.element._props["name"] = to_value(ref_ui)
+    #         self.element.update()

ex4nicegui-0.6.3/ex4nicegui/reactive/officials/tab_panel.py

@@ -0,0 +1,23 @@
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import BindableUi
+
+
+class TabPanelBindableUi(BindableUi[ui.tab_panel]):
+    def __init__(
+        self,
+        name: TMaybeRef[str],
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=["name"],
+        )
+
+        element = ui.tab_panel(**pc.get_values_kws())
+        super().__init__(element)
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore

ex4nicegui-0.6.3/ex4nicegui/reactive/officials/tab_panels.py

@@ -0,0 +1,46 @@
+from typing import Any, Callable, Optional
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    to_value,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import BindableUi
+
+
+class TabPanelsBindableUi(BindableUi[ui.tab_panels]):
+    def __init__(
+        self,
+        value: Optional[TMaybeRef[str]] = None,
+        *,
+        on_change: Optional[Callable[..., Any]] = None,
+        animated: TMaybeRef[bool] = True,
+        keep_alive: TMaybeRef[bool] = True,
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=["value", "animated", "keep_alive"],
+            v_model=("value", "on_change"),
+            events=["on_change"],
+        )
+
+        element = ui.tab_panels(**pc.get_values_kws())
+        super().__init__(element)
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    @property
+    def value(self):
+        return self.element.value
+
+    def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_value(self, ref_ui: TMaybeRef):
+        @self._ui_effect
+        def _():
+            self.element.set_value(to_value(ref_ui))

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/ex4nicegui/reactive/officials/table.py

@@ -6,7 +6,7 @@ from typing import (
     Dict,
 )
 from typing_extensions import Literal
-from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.reactive.utils import ParameterClassifier, dataframe2col_str
 import ex4nicegui.utils.common as utils_common
 from ex4nicegui.utils.signals import (
     ReadonlyRef,
@@ -17,6 +17,7 @@ from ex4nicegui.utils.signals import (
     to_value,
     to_raw,
     on,
+    RefWrapper,
 )
 from nicegui import ui
 from .base import BindableUi
@@ -34,8 +35,16 @@ class TableBindableUi(BindableUi[ui.table]):
         on_select: Optional[Callable[..., Any]] = None,
         on_pagination_change: Optional[Callable[..., Any]] = None,
     ) -> None:
+        local_args = locals()
+        rows_data = local_args.get("rows")
+        if isinstance(rows_data, RefWrapper):
+            local_args.update(rows=lambda: rows_data.value)
+        columns_data = local_args.get("columns")  # type: ignore
+        if isinstance(columns_data, RefWrapper):
+            local_args.update(columns=lambda: columns_data.value)
+
         pc = ParameterClassifier(
-            locals(),
+            local_args,
             maybeRefs=[
                 "columns",
                 "rows",
@@ -57,7 +66,7 @@ class TableBindableUi(BindableUi[ui.table]):
 
         self._arg_selection = selection
         self._arg_row_key = row_key
-        self._selection_ref: ReadonlyRef[List[Any]] = to_ref([])
+        self._selection_ref: ReadonlyRef[List[Any]] = to_ref([])  # type: ignore
 
         def on_selection(_):
             self._selection_ref.value = self.element.selected  # type: ignore
@@ -68,8 +77,9 @@ class TableBindableUi(BindableUi[ui.table]):
     def selection_ref(self):
         return self._selection_ref
 
-    @staticmethod
+    @classmethod
     def from_pandas(
+        cls,
         df: TMaybeRef,
         *,
         columns_define_fn: Optional[Callable[[str], Dict]] = None,
@@ -90,15 +100,14 @@ class TableBindableUi(BindableUi[ui.table]):
             "on_pagination_change": on_pagination_change,
         }
 
-        if is_ref(df):
+        if is_ref(df) or isinstance(df, Callable):
 
             @ref_computed
-            def cp_rows():
-                return df.value.to_dict("records")
+            def cp_rows_columns():
+                copy_df = dataframe2col_str(to_value(df))
+                rows = copy_df.to_dict("records")
 
-            @ref_computed
-            def cp_cols():
-                return [
+                columns = [
                     {
                         **{
                             "name": col,
@@ -107,11 +116,18 @@ class TableBindableUi(BindableUi[ui.table]):
                         },
                         **columns_define_fn(col),  # type: ignore
                     }
-                    for col in df.value.columns
+                    for col in copy_df.columns
                 ]
 
-            return TableBindableUi(cp_cols, cp_rows, **other_kws)
+                return rows, columns
+
+            return cls(
+                lambda: cp_rows_columns.value[1],
+                lambda: cp_rows_columns.value[0],
+                **other_kws,
+            )
 
+        df = dataframe2col_str(df)
         rows = df.to_dict("records")  # type: ignore
 
         cols = [
@@ -125,7 +141,7 @@ class TableBindableUi(BindableUi[ui.table]):
             }
             for col in df.columns  # type: ignore
         ]
-        return TableBindableUi(cols, rows, **other_kws)
+        return cls(cols, rows, **other_kws)
 
     def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
         if prop == "dataframe":

ex4nicegui-0.6.3/ex4nicegui/reactive/officials/tabs.py

@@ -0,0 +1,43 @@
+from typing import Any, Callable, Optional
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    to_value,
+    _TMaybeRef as TMaybeRef,
+)
+from nicegui import ui
+from .base import BindableUi
+
+
+class TabsBindableUi(BindableUi[ui.tabs]):
+    def __init__(
+        self,
+        value: Optional[TMaybeRef[str]] = None,
+        on_change: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=["value"],
+            v_model=("value", "on_change"),
+            events=["on_change"],
+        )
+
+        element = ui.tabs(**pc.get_values_kws())
+        super().__init__(element)
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    @property
+    def value(self):
+        return self.element.value
+
+    def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_value(self, ref_ui: TMaybeRef):
+        @self._ui_effect
+        def _():
+            self.element.set_value(to_value(ref_ui))

ex4nicegui-0.6.3/ex4nicegui/reactive/transitionGroup.js

@@ -0,0 +1,39 @@
+export default {
+    props: {
+        // childOrderKey: Array,
+        // transitionGroupArgs: Array,
+    },
+    data() {
+        return {
+        }
+    },
+    mounted() {
+    },
+    render() {
+        // debugger
+        const h = Vue.h
+        const vfgt = Vue.Fragment
+        const slotBox = this.$slots.default()
+        console.log('tg:', slotBox);
+        const wrap = () => [h(vfgt, slotBox)]
+        // const wrap = slotBox
+        console.log(wrap);
+
+
+        // slotBox[0].children = this.childOrderKey.map(idx => {
+        //     return slotBox[0].children[idx]
+        // })
+        // console.log(slots);
+
+        return h(
+            Vue.TransitionGroup,
+            {
+                tag: 'span',
+                name: 'list',
+                // css: false,
+                // ...this.transitionGroupArgs
+            }, wrap
+        )
+
+    }
+}

ex4nicegui-0.6.3/ex4nicegui/reactive/transitionGroup.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+from nicegui.element import Element
+from typing import (
+    Any,
+    Dict,
+    List,
+)
+
+
+class TransitionGroup(Element, component="transitionGroup.js"):
+    def __init__(self) -> None:
+        super().__init__()
+
+    def apply_transition_group(self, args: Dict[str, Any]):
+        self._props["transitionGroupArgs"] = args
+        self.update()
+
+    def update_child_order_keys(self, keys: List[Any]):
+        print(f"keys:{keys=}")
+        self._props["childOrderKey"] = keys
+        self.update()
+
+
+def transition_group(fn):
+    pass

{ex4nicegui-0.6.1 → ex4nicegui-0.6.3}/ex4nicegui/reactive/utils.py

@@ -15,6 +15,11 @@ from typing import (
 from ex4nicegui.utils.signals import is_ref, to_value, is_setter_ref
 from nicegui.events import handle_event
 
+try:
+    import pandas as pd
+except ImportError:
+    pass
+
 
 @runtime_checkable
 class GetItemProtocol(Protocol):
@@ -113,3 +118,30 @@ def set_attribute(
         obj[name] = value
     else:
         setattr(obj, name, value)  # type: ignore
+
+
+def dataframe2col_str(df, copy=True):
+    if isinstance(df.columns, pd.MultiIndex):
+        raise ValueError(
+            "MultiIndex columns are not supported. "
+            "You can convert them to strings using something like "
+            '`df.columns = ["_".join(col) for col in df.columns.values]`.'
+        )
+
+    date_cols = df.columns[df.dtypes == "datetime64[ns]"]
+    time_cols = df.columns[df.dtypes == "timedelta64[ns]"]
+    complex_cols = df.columns[df.dtypes == "complex128"]
+    period_cols = df.columns[df.dtypes == "period[M]"]
+    if (
+        len(date_cols) != 0
+        or len(time_cols) != 0
+        or len(complex_cols) != 0
+        or len(period_cols) != 0
+    ):
+        df = df.copy() if copy else df
+        df[date_cols] = df[date_cols].astype(str)
+        df[time_cols] = df[time_cols].astype(str)
+        df[complex_cols] = df[complex_cols].astype(str)
+        df[period_cols] = df[period_cols].astype(str)
+
+    return df

ex4nicegui-0.6.3/ex4nicegui/reactive/vfor.js

@@ -0,0 +1,13 @@
+export default {
+    props: { itemIds: Array },
+
+    render() {
+        const slotBox = this.$slots.default()
+
+        const slots = this.itemIds.map(({ elementId }) => {
+            return slotBox.find(v => v.key === elementId)
+        });
+
+        return slots
+    }
+}