ex4nicegui 0.6.2__tar.gz → 0.6.4__tar.gz

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/PKG-INFO

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

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui/__init__.py

@@ -45,4 +45,4 @@ __all__ = [
     "is_setter_ref",
 ]
 
-__version__ = "0.6.2"
+__version__ = "0.6.4"

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui/reactive/__init__.py

@@ -46,6 +46,11 @@ 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 .officials.element import ElementBindableUi as element
 from .q_pagination import PaginationBindableUi as q_pagination
 
 from .local_file_picker import local_file_picker
@@ -63,6 +68,11 @@ pagination = q_pagination
 
 
 __all__ = [
+    "element",
+    "tab_panels",
+    "tab_panel",
+    "tabs",
+    "tab",
     "circular_progress",
     "knob",
     "UploadResult",

ex4nicegui-0.6.4/ex4nicegui/reactive/empty.js

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

ex4nicegui-0.6.4/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.2 → ex4nicegui-0.6.4}/ex4nicegui/reactive/officials/base.py

@@ -244,6 +244,10 @@ class BindableUi(Generic[TWidget]):
 
         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.2 → ex4nicegui-0.6.4}/ex4nicegui/reactive/officials/echarts.py

@@ -2,7 +2,7 @@ from pathlib import Path
 from typing import Any, Callable, Dict, List, Union, cast, Optional
 from typing_extensions import Literal
 from ex4nicegui.reactive.utils import ParameterClassifier
-from ex4nicegui.utils.apiEffect import ui_effect
+from ex4nicegui.utils.signals import on
 
 from ex4nicegui.utils.signals import (
     ReadonlyRef,
@@ -10,6 +10,7 @@ from ex4nicegui.utils.signals import (
     ref_computed,
     _TMaybeRef as TMaybeRef,
     to_value,
+    to_raw,
 )
 from .base import BindableUi
 from ex4nicegui.reactive.EChartsComponent.ECharts import (
@@ -136,10 +137,10 @@ class EChartsBindableUi(BindableUi[echarts]):
         return super().bind_prop(prop, ref_ui)
 
     def bind_options(self, ref_ui: ReadonlyRef[Dict]):
-        @ui_effect
+        @on(ref_ui)
         def _():
             ele = self.element
-            ele.update_options(to_value(ref_ui), self.__update_setting)
+            ele.update_options(to_raw(to_value(ref_ui)), self.__update_setting)
             ele.update()
 
         return self

ex4nicegui-0.6.4/ex4nicegui/reactive/officials/element.py

@@ -0,0 +1,19 @@
+from typing import (
+    Any,
+)
+from nicegui import ui
+from .base import BindableUi
+
+
+class ElementBindableUi(BindableUi[ui.element]):
+    def __init__(self, tag: str) -> None:
+        element = ui.element(tag)
+
+        super().__init__(element)
+
+    def __enter__(self):
+        self.element.__enter__()
+        return self
+
+    def __exit__(self, *_: Any):
+        self.element.__exit__(*_)

ex4nicegui-0.6.4/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.4/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.4/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.2 → ex4nicegui-0.6.4}/ex4nicegui/reactive/officials/table.py

@@ -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",

ex4nicegui-0.6.4/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.4/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.4/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.4/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
+    }
+}

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui/reactive/vfor.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 from nicegui.element import Element
-from nicegui import ui
+from nicegui import context
 from ex4nicegui.utils.clientScope import _CLIENT_SCOPE_MANAGER
 from ex4nicegui.utils.signals import (
     TReadonlyRef,
@@ -8,6 +8,9 @@ from ex4nicegui.utils.signals import (
     to_ref,
     to_ref_wrapper,
     TGetterOrReadonlyRef,
+    to_value,
+    is_reactive,
+    RefWrapper,
 )
 from typing import (
     Any,
@@ -24,9 +27,25 @@ from functools import partial
 from dataclasses import dataclass
 from signe.core.scope import Scope
 from .utils import get_attribute
+from ex4nicegui.reactive.empty import Empty
+# from .transitionGroup import TransitionGroup
 
 _T = TypeVar("_T")
-_T_data = TGetterOrReadonlyRef[List[Any]]
+_T_data = Union[List[Any], TGetterOrReadonlyRef[List[Any]], RefWrapper]
+
+
+class VforItem(Empty):
+    pass
+
+
+class VforContainer(Element, component="vfor.js"):
+    def __init__(self) -> None:
+        super().__init__()
+        self._props["itemIds"] = []
+
+    def update_items(self, item_ids: List[Dict]):
+        self._props["itemIds"] = item_ids
+        self.update()
 
 
 class VforStore(Generic[_T]):
@@ -40,10 +59,10 @@ class VforStore(Generic[_T]):
 
     def get(self) -> TReadonlyRef[_T]:
         def base_setter(value):
-            self._source.value[self._data_index.value] = value
+            to_value(self._source)[self._data_index.value] = value
 
         wrapper = to_ref_wrapper(
-            lambda: self._source.value[self._data_index.value],
+            lambda: to_value(self._source)[self._data_index.value],
             base_setter,
         )
         wrapper._is_readonly = True
@@ -62,10 +81,6 @@ class StoreItem:
     scope: Scope
 
 
-class VforContainer(Element, component="vfor.js"):
-    pass
-
-
 def _get_key_with_index(idx: int, data: Any):
     return idx
 
@@ -112,20 +127,25 @@ class vfor(Generic[_T]):
         self,
         data: _T_data,
         *,
-        key: Optional[str] = None,
+        key: Optional[Union[str, Callable[[int, Any], Any]]] = None,
     ) -> None:
-        self._container = VforContainer()
-        self._data = data
-        self._get_key = (
-            _get_key_with_index if key is None else partial(_get_key_with_getter, key)
-        )
+        self._vfor_container = VforContainer()
+        self._data = to_ref_wrapper(lambda: data) if is_reactive(data) else data
+        self._get_key = _get_key_with_index
+
+        if isinstance(key, str):
+            self._get_key = partial(_get_key_with_getter, key)
+        elif isinstance(key, Callable):
+            self._get_key = key
+
         self._store_map: Dict[Union[Any, int], StoreItem] = {}
 
     def __call__(self, fn: Callable[[Any], None]):
         def build_element(index: int, value):
             key = self._get_key(index, value)
-            with VforContainer() as element:
-                store = VforStore(self._data, index)
+
+            with self._vfor_container, VforItem() as element:
+                store = VforStore(self._data, index)  # type: ignore
                 scope = _CLIENT_SCOPE_MANAGER.new_scope()
 
                 @scope.run
@@ -134,54 +154,46 @@ class vfor(Generic[_T]):
 
             return key, element, store, scope
 
-        with self._container:
-            for idx, value in enumerate(self._data.value):
-                key, element, store, scope = build_element(idx, value)
-                self._store_map[key] = StoreItem(store, element.id, scope)
+        for idx, value in enumerate(to_value(self._data)):  # type: ignore
+            key, element, store, scope = build_element(idx, value)
+            self._store_map[key] = StoreItem(store, element.id, scope)
+
+        ng_client = context.get_client()
 
         @on(self._data, deep=True)
         def _():
             data_map = {
-                self._get_key(idx, d): d for idx, d in enumerate(self._data.value)
+                self._get_key(idx, d): d for idx, d in enumerate(to_value(self._data))
             }
 
-            temp_box = ui.element("div")
-
-            element_map: Dict[int, ui.element] = {}
-            for element in list(self._container):
-                element.move(temp_box)
-                element_map[element.id] = element
-
-            new_store_map: Dict[Union[Any, int], StoreItem] = {}
-
-            with self._container:
-                for idx, (key, value) in enumerate(data_map.items()):
-                    store_item = self._store_map.get(key)
-                    if store_item:
-                        # `data` may have changed the value of a dictionary item,
-                        # so should update the values in the store one by one.
-                        store_item.store.update(idx)
-                        element = element_map.get(store_item.elementId)
-                        assert element
-                        element.move(self._container)
-
-                        new_store_map[key] = store_item
-                    else:
-                        # new row item
-                        key, element, store, score = build_element(idx, value)
-                        store_item = StoreItem(store, element.id, score)
-                        element.move(self._container)
-                        new_store_map[key] = store_item
-
-            del_store_items = tuple(
-                value
+            for idx, (key, value) in enumerate(data_map.items()):
+                store_item = self._store_map.get(key)
+                if store_item:
+                    # `data` may have changed the value of a dictionary item,
+                    # so should update the values in the store one by one.
+                    store_item.store.update(idx)
+
+                else:
+                    # new row item
+                    key, element, store, score = build_element(idx, value)
+                    self._store_map[key] = StoreItem(store, element.id, score)
+
+            # remove item
+            remove_items = [
+                (key, value)
                 for key, value in self._store_map.items()
-                if key not in new_store_map
+                if key not in data_map
+            ]
+
+            for key, item in remove_items:
+                target = ng_client.elements.get(item.elementId)
+                self._vfor_container.remove(target)  # type: ignore
+                item.scope.dispose()
+                del self._store_map[key]
+
+            self._vfor_container.update_items(
+                [
+                    {"key": key, "elementId": self._store_map.get(key).elementId}  # type: ignore
+                    for key in data_map.keys()
+                ]
             )
-
-            for store_item in del_store_items:
-                store_item.scope.dispose()
-
-            self._store_map.clear()
-            self._store_map = new_store_map
-            temp_box.delete()

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui/utils/signals.py

@@ -99,7 +99,7 @@ def is_ref(obj):
     return signe.is_signal(obj) or isinstance(obj, (RefWrapper))
 
 
-def to_value(obj: _TMaybeRef[T]) -> T:
+def to_value(obj: Union[_TMaybeRef[T], RefWrapper]) -> T:
     if is_ref(obj):
         return obj.value  # type: ignore
     if isinstance(obj, Callable):
@@ -329,7 +329,7 @@ class effect_refreshable:
 
 
 def on(
-    refs: Union[TGetterOrReadonlyRef, Sequence[TGetterOrReadonlyRef]],
+    refs: Union[TGetterOrReadonlyRef, RefWrapper, Sequence[TGetterOrReadonlyRef]],
     onchanges=False,
     priority_level=1,
     effect_kws: Optional[Dict[str, Any]] = None,
@@ -349,8 +349,10 @@ def on(
 
     """
     effect_kws = effect_kws or {}
-    # if not isinstance(refs, Sequence):
-    #     refs = [refs]
+    if not isinstance(refs, Sequence):
+        refs = [refs]  # type: ignore
+
+    refs = [(lambda: ref.value) if isinstance(ref, RefWrapper) else ref for ref in refs]  # type: ignore
 
     effect_kws.update({"priority_level": priority_level})
 

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui.egg-info/PKG-INFO

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

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui.egg-info/SOURCES.txt

@@ -76,10 +76,14 @@ ex4nicegui/libs/gsap/utils/matrix.js
 ex4nicegui/libs/gsap/utils/paths.js
 ex4nicegui/libs/gsap/utils/strings.js
 ex4nicegui/reactive/__init__.py
+ex4nicegui/reactive/empty.js
+ex4nicegui/reactive/empty.py
 ex4nicegui/reactive/fileWatcher.py
 ex4nicegui/reactive/local_file_picker.py
 ex4nicegui/reactive/q_pagination.py
 ex4nicegui/reactive/rxui.py
+ex4nicegui/reactive/transitionGroup.js
+ex4nicegui/reactive/transitionGroup.py
 ex4nicegui/reactive/usePagination.py
 ex4nicegui/reactive/utils.py
 ex4nicegui/reactive/vfor.js
@@ -109,6 +113,7 @@ ex4nicegui/reactive/officials/column.py
 ex4nicegui/reactive/officials/date.py
 ex4nicegui/reactive/officials/drawer.py
 ex4nicegui/reactive/officials/echarts.py
+ex4nicegui/reactive/officials/element.py
 ex4nicegui/reactive/officials/expansion.py
 ex4nicegui/reactive/officials/grid.py
 ex4nicegui/reactive/officials/html.js
@@ -125,7 +130,11 @@ ex4nicegui/reactive/officials/row.py
 ex4nicegui/reactive/officials/select.py
 ex4nicegui/reactive/officials/slider.py
 ex4nicegui/reactive/officials/switch.py
+ex4nicegui/reactive/officials/tab.py
+ex4nicegui/reactive/officials/tab_panel.py
+ex4nicegui/reactive/officials/tab_panels.py
 ex4nicegui/reactive/officials/table.py
+ex4nicegui/reactive/officials/tabs.py
 ex4nicegui/reactive/officials/textarea.py
 ex4nicegui/reactive/officials/upload.py
 ex4nicegui/reactive/officials/utils.py

{ex4nicegui-0.6.2 → ex4nicegui-0.6.4}/ex4nicegui.egg-info/requires.txt

@@ -1,4 +1,4 @@
-signe>=0.4.11
+signe>=0.4.14
 nicegui>=1.4.0
 typing_extensions
 executing