ex4nicegui 0.8.10__py3-none-any.whl → 0.9.1__py3-none-any.whl

ex4nicegui/__init__.py

@@ -8,8 +8,6 @@ from ex4nicegui.utils.types import (
 )
 from ex4nicegui.utils.scheduler import next_tick
 from ex4nicegui.utils.signals import (
-    effect,
-    effect_refreshable,
     to_raw,
     is_ref,
     to_ref,
@@ -23,9 +21,11 @@ from ex4nicegui.utils.signals import (
     batch,
     is_reactive,
 )
+from ex4nicegui.utils.refreshable import effect, effect_refreshable
 from ex4nicegui.utils.asyncComputed import async_computed
 from ex4nicegui.utils.clientScope import new_scope
 from ex4nicegui.reactive.EChartsComponent.ECharts import reset_echarts_dependencies
+from ex4nicegui.utils.page_state import PageState
 from .version import __version__
 
 __all__ = [
@@ -53,5 +53,6 @@ __all__ = [
     "new_scope",
     "next_tick",
     "reset_echarts_dependencies",
+    "PageState",
     "__version__",
 ]

ex4nicegui/bi/dataSource.py

@@ -182,8 +182,7 @@ class DataSource:
 
             @ng_client.on_disconnect
             def _(e: Client):
-                if not e.shared:
-                    self._component_map.remove_client(e.id)
+                self._component_map.remove_client(e.id)
 
         info = ComponentInfo(
             ComponentInfoKey(client_id, element_id), update_callback, uiResult=ui_result

ex4nicegui/bi/elements/ui_aggrid.py

@@ -57,8 +57,7 @@ def ui_aggrid(
         data = self._dataSource.get_filtered_data(cp)
         new_opts = self._dataSource._idataSource.get_aggrid_options(data)
         options = _merge_options(fixed_options, new_opts)
-        cp._props["options"] = options
-        cp.update()
+        cp.options = {**options, "theme": kwargs.get("theme", "quartz")}
 
     self._dataSource._register_component(cp.id, on_source_update)
 

ex4nicegui/bi/protocols.py

@@ -9,14 +9,11 @@ from ex4nicegui.utils import common as utils_common
 
 
 class IDataSourceAble(Protocol):
-    def get_data(self) -> Any:
-        ...
+    def get_data(self) -> Any: ...
 
-    def reload(self, data) -> None:
-        ...
+    def reload(self, data) -> None: ...
 
-    def apply_filters(self, data, filters: List[_TFilterCallback]) -> Any:
-        ...
+    def apply_filters(self, data, filters: List[_TFilterCallback]) -> Any: ...
 
     def duplicates_column_values(
         self,
@@ -25,30 +22,23 @@ class IDataSourceAble(Protocol):
         *,
         exclude_null_value=True,
         sort_options: Optional[_TDuplicates_column_values_sort_options] = None,
-    ) -> List:
-        ...
+    ) -> List: ...
 
-    def get_aggrid_options(self, data) -> Dict:
-        ...
+    def get_aggrid_options(self, data) -> Dict: ...
 
-    def get_table_options(self, data) -> Dict:
-        ...
+    def get_table_options(self, data) -> Dict: ...
 
-    def slider_check(self, data, column_name: str) -> None:
-        ...
+    def slider_check(self, data, column_name: str) -> None: ...
 
     def slider_min_max(
         self, data, column_name: str
-    ) -> Tuple[Optional[float], Optional[float]]:
-        ...
+    ) -> Tuple[Optional[float], Optional[float]]: ...
 
-    def range_check(self, data, column_name: str) -> None:
-        ...
+    def range_check(self, data, column_name: str) -> None: ...
 
     def range_min_max(
         self, data, column_name: str
-    ) -> Tuple[Optional[float], Optional[float]]:
-        ...
+    ) -> Tuple[Optional[float], Optional[float]]: ...
 
 
 class CallableDataSourceAble(IDataSourceAble):

ex4nicegui/layout/rxFlex/index.py

@@ -53,7 +53,6 @@ class rx_column(ui.column, rx_flex_box):
         vertical: TColumn_Vertical = "top",
     ) -> None:
         super().__init__()
-        self.tailwind.align_items
         self.horizontal(horizontal)
         self.vertical(vertical)
 

ex4nicegui/reactive/EChartsComponent/ECharts.js

@@ -1,4 +1,4 @@
-import 'echarts'
+import { echarts } from "nicegui-echart";
 import { convertDynamicProperties } from "../../static/utils/dynamic_properties.js";
 
 const registerThemeTask = Promise.all(

ex4nicegui/reactive/EChartsComponent/ECharts.py

@@ -11,18 +11,14 @@ from nicegui.events import handle_event, UiEventArguments, GenericEventArguments
 from nicegui.element import Element
 from nicegui.awaitable_response import AwaitableResponse
 from pathlib import Path
-import nicegui
 
 from .types import (
     _T_event_name,
 )
 from .utils import get_bound_event_args, create_event_handler_args
 
-NG_ROOT = Path(nicegui.__file__).parent / "elements"
-libraries = [NG_ROOT / "lib/echarts/echarts.min.js"]
 
-
-class echarts(Element, component="ECharts.js", dependencies=libraries):  # type: ignore
+class echarts(Element, component="ECharts.js"):
     def __init__(
         self,
         options: Optional[dict] = None,

ex4nicegui/reactive/UseDraggable/UseDraggable.py

@@ -125,9 +125,9 @@ class UseDraggable(Element, component="UseDraggable.js"):
         self.on("update", inner_handler, args=_Update_Args)
 
     def apply(self, target: Element):
-        assert (
-            self.__target_id is None
-        ), "draggable can only be applied to one current element"
+        assert self.__target_id is None, (
+            "draggable can only be applied to one current element"
+        )
         self.__target_id = target.id
         self._props["elementId"] = self.__target_id
         # self.run_method("applyTargetId", str(self.__target_id))

ex4nicegui/reactive/__init__.py

@@ -63,7 +63,7 @@ from .officials.range import LazyRangeBindableUi as lazy_range
 from .officials.tree import TreeBindableUi as tree
 from .officials.spinner import SpinnerBindableUi as spinner
 
-from .local_file_picker import local_file_picker
+
 from .UseDraggable.UseDraggable import use_draggable
 from .useMouse.UseMouse import use_mouse
 
@@ -73,7 +73,7 @@ from .fileWatcher import FilesWatcher
 from .mermaid.mermaid import Mermaid as mermaid
 from .officials.dialog import DialogBindableUi as dialog
 from .vfor import vfor, VforStore
-from .vmodel import vmodel
+from ._vmodel import vmodel
 from .view_model import ViewModel, var, cached_var, list_var, dict_var
 
 pagination = q_pagination
@@ -89,7 +89,6 @@ __all__ = [
     "circular_progress",
     "knob",
     "UploadResult",
-    "local_file_picker",
     "use_draggable",
     "use_mouse",
     "use_pagination",

ex4nicegui/reactive/_vmodel.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+import warnings
+from ex4nicegui.utils.signals import (
+    RefWrapper,
+    TRef,
+    to_raw,
+    to_ref_wrapper,
+    to_value,
+    is_reactive,
+    is_ref,
+)
+from typing import (
+    Any,
+    Union,
+    cast,
+    Tuple,
+)
+
+from ex4nicegui.reactive.systems.object_system import get_attribute, set_attribute
+from ex4nicegui.utils.types import _TMaybeRef as TMaybeRef, Ref
+
+
+def create_writeable_wrapper(ref_obj: TRef, attrs: Tuple[Union[str, int], ...]):
+    if not attrs:
+
+        def maybe_ref_getter():
+            return to_value(ref_obj)
+
+        def reactive_getter():
+            return to_raw(ref_obj)
+
+        def setter(value):
+            pass
+
+        wrapper = to_ref_wrapper(
+            reactive_getter if is_reactive(ref_obj) else maybe_ref_getter,
+            setter,
+        )
+        wrapper._is_readonly = False
+        return wrapper
+
+    def getter():
+        obj = get_attribute(to_value(ref_obj), attrs[0])
+        for attr in attrs[1:]:
+            obj = get_attribute(obj, attr)
+
+        return obj
+
+    def setter(value):
+        obj = to_value(ref_obj)
+
+        for attr in attrs[:-1]:
+            obj = get_attribute(obj, attr)
+
+        set_attribute(obj, attrs[-1], value)
+
+    wrapper = to_ref_wrapper(
+        getter,
+        setter,
+    )
+    wrapper._is_readonly = False
+    return wrapper
+
+
+def vmodel(ref_obj: Union[TRef[Any], Any], *attrs: Union[str, int]) -> Any:
+    """Create a two-way binding on a form input element or a component.
+
+    @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#vmodel
+    @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#vmodel
+
+    Args:
+        expr (Any): _description_
+
+    ## Examples
+
+    .. code-block:: python
+        from ex4nicegui.reactive import rxui
+        from ex4nicegui import deep_ref
+
+        data = deep_ref({"a": 1, "b": [1, 2, 3, 4]})
+
+        rxui.label(lambda: f"{data.value=!s}")
+
+        # No binding effect
+        rxui.input(value=data.value["a"])
+
+        # readonly binding
+        rxui.input(value=lambda: data.value["a"])
+
+        # two-way binding
+        rxui.input(value=rxui.vmodel(data.value,'a'))
+
+
+    """
+
+    if not is_ref(ref_obj):
+        result = cast(Any, ref_obj)
+        for attr in attrs:
+            result = result[attr]
+
+        return result
+
+    if isinstance(ref_obj, RefWrapper):
+        ref_obj._is_readonly = False
+
+    if attrs:
+        wrapper = create_writeable_wrapper(ref_obj, attrs)
+
+        return cast(
+            TRef,
+            wrapper,
+        )
+    else:
+        warnings.warn(
+            """Maybe you don't need to use vmodel""",
+            stacklevel=2,
+        )
+
+    return cast(
+        TRef,
+        ref_obj,
+    )
+
+
+def vmodel_with_index(ref: Ref, index: TMaybeRef[int], *keys: Union[str, int]) -> Ref:
+    proxy = ref.value
+
+    def getter():
+        item = proxy[to_value(index)]
+        result = item
+
+        for k in keys:
+            result = get_attribute(result, k)
+        return result
+
+    def setter(value):
+        item = proxy[to_value(index)]
+
+        if len(keys) == 1:
+            set_attribute(item, keys[0], value)
+            return
+
+        obj = get_attribute(item, keys[0])
+
+        for k in keys[1:-1]:
+            set_attribute(obj, k, get_attribute(obj, k))
+
+        set_attribute(obj, keys[-1], value)
+
+    return RefWrapper(getter, setter)  # type: ignore

ex4nicegui/reactive/base.py

@@ -25,7 +25,7 @@ from ex4nicegui.utils.signals import (
 )
 from ex4nicegui.utils.clientScope import new_scope
 from ex4nicegui.utils.types import _TMaybeRef as TMaybeRef
-from nicegui import Tailwind, ui
+from nicegui import ui
 from nicegui.elements.mixins.text_element import TextElement
 from nicegui.elements.mixins.value_element import ValueElement
 from ex4nicegui.reactive.services.reactive_service import inject_handle_delete
@@ -58,7 +58,6 @@ class BindableUi(Generic[TWidget]):
     def __init__(self, element: TWidget) -> None:
         self._element = element
         inject_handle_delete(self.element, self._on_element_delete)
-        self.tailwind = Tailwind(cast(ui.element, self._element))
         self._effect_scope = new_scope()
         self.__used_scope_style = False
 
@@ -185,7 +184,7 @@ class BindableUi(Generic[TWidget]):
 
             def props_str():
                 props_dict = (
-                    f"""{name if isinstance(raw_value,bool) else f"{name}='{raw_value}'"}"""
+                    f"""{name if isinstance(raw_value, bool) else f"{name}='{raw_value}'"}"""
                     for name, value in props.items()
                     if (raw_value := to_value(value))
                 )

ex4nicegui/reactive/deferredTask.py

@@ -15,11 +15,8 @@ class DeferredTask:
                 task()
 
             # Avoid events becoming ineffective due to page refresh when sharing the client.
-            if not client.shared:
-                # In a shared page, execution is required with every refresh.
-                # note:https://github.com/CrystalWindSnake/ex4nicegui/issues/227
-                self._tasks.clear()
-                client.connect_handlers.remove(on_client_connect)  # type: ignore
+            self._tasks.clear()
+            client.connect_handlers.remove(on_client_connect)  # type: ignore
 
         ui.context.client.on_connect(on_client_connect)
 

ex4nicegui/reactive/mermaid/{mermaid.js → ex4ng_mermaid.js}

@@ -1,4 +1,4 @@
-import mermaid from "mermaid";
+import { mermaid } from "nicegui-mermaid";
 import { select as d3Select } from "d3-selection";
 import { zoom as d3Zoom, zoomIdentity } from "d3-zoom";
 

ex4nicegui/reactive/mermaid/mermaid.py

@@ -1,19 +1,14 @@
 from typing import Callable, List, Optional
 from nicegui.elements.mixins.content_element import ContentElement
 from pathlib import Path
-import nicegui
 from dataclasses import dataclass
 from nicegui.events import UiEventArguments
 from nicegui.dataclasses import KWONLY_SLOTS
 
-NG_ROOT = Path(nicegui.__file__).parent / "elements"
-
 EX4_LIBS_ROOT = Path(__file__).parent.parent.parent / "libs"
 
 dependencies = [
-    NG_ROOT / "lib/mermaid/mermaid.esm.min.mjs",
     EX4_LIBS_ROOT / "d3/*.js",
-    NG_ROOT / "lib/mermaid/*.js",
 ]
 
 
@@ -24,7 +19,7 @@ class NodeClickEventArguments(UiEventArguments):
 
 class Mermaid(  # type: ignore
     ContentElement,
-    component="mermaid.js",
+    component="ex4ng_mermaid.js",
     dependencies=dependencies,  # type: ignore
 ):
     CONTENT_PROP = "content"

ex4nicegui/reactive/mixins/flexLayout.py

@@ -13,11 +13,9 @@ class FlexWrapMixin(Protocol):
     _ui_signal_on: Callable[[Callable[..., Any]], signe.Effect[None]]
 
     @property
-    def element(self) -> ui.element:
-        ...
+    def element(self) -> ui.element: ...
 
-    def bind_style(self, classes) -> Self:
-        ...
+    def bind_style(self, classes) -> Self: ...
 
     def bind_wrap(self, value: TMaybeRef[bool]) -> Self:
         return self.bind_style(
@@ -35,11 +33,9 @@ class FlexAlignItemsMixin(Protocol):
     _ui_signal_on: Callable[[Callable[..., Any]], signe.Effect[None]]
 
     @property
-    def element(self) -> ui.element:
-        ...
+    def element(self) -> ui.element: ...
 
-    def bind_classes(self, classes) -> Self:
-        ...
+    def bind_classes(self, classes) -> Self: ...
 
     def bind_align_items(self, value: TMaybeRef[str]):
         return self.bind_classes(lambda: f"items-{to_value(value)}")

ex4nicegui/reactive/mixins/value_element.py

@@ -10,8 +10,7 @@ class ValueElementMixin(Protocol, Generic[T]):
     _ui_signal_on: Callable[[Callable[..., Any]], signe.Effect[None]]
 
     @property
-    def element(self) -> ValueElement:
-        ...
+    def element(self) -> ValueElement: ...
 
     def bind_value(self, value: TMaybeRef[T]):
         @self._ui_signal_on(value)  # type: ignore

ex4nicegui/reactive/officials/echarts.py

@@ -140,7 +140,7 @@ class EChartsBindableUi(BindableUi[echarts]):
         const value = {{
             src: '{src}',
             type: '{type}',
-            specialAreas: {json.dumps(special_areas).decode('utf-8')}
+            specialAreas: {json.dumps(special_areas).decode("utf-8")}
         }}
 
         window.ex4ngEchartsMapTasks.set('{map_name}', value);

ex4nicegui/reactive/systems/object_system.py

@@ -8,14 +8,12 @@ from typing import (
 
 @runtime_checkable
 class GetItemProtocol(Protocol):
-    def __getitem__(self, key):
-        ...
+    def __getitem__(self, key): ...
 
 
 @runtime_checkable
 class SetItemProtocol(Protocol):
-    def __setitem__(self, key, value):
-        ...
+    def __setitem__(self, key, value): ...
 
 
 def get_attribute(obj: Union[object, GetItemProtocol], name: Union[str, int]) -> Any:

ex4nicegui/reactive/usePagination.py

@@ -17,11 +17,9 @@ def _clamp(value, min_v, max_v) -> int:
 
 
 class _SourceProtocol(Protocol):
-    def __len__(self) -> int:
-        ...
+    def __len__(self) -> int: ...
 
-    def __getitem__(self, __idx: slice) -> Any:
-        ...
+    def __getitem__(self, __idx: slice) -> Any: ...
 
 
 class PaginationRef:

ex4nicegui/reactive/vfor.py

@@ -68,6 +68,7 @@ def wrapper_getter_setter(ref: Ref, index: Ref[int], *keys: Union[str, int]):
 
         if len(keys) == 0:
             proxy[index.value] = value
+            return
 
         if len(keys) == 1:
             item[keys[0]] = value

ex4nicegui/toolbox/core/vue_use.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Dict, List, Optional
+from typing import Any, Callable, List, Optional
 from nicegui.element import Element
 from collections import defaultdict
 

ex4nicegui/utils/apiEffect.py

@@ -52,8 +52,7 @@ def ui_effect(
     debug_trigger: Optional[Callable] = None,
     debug_name: Optional[str] = None,
     scope: Optional[Scope] = None,
-) -> signe.Effect[None]:
-    ...
+) -> signe.Effect[None]: ...
 
 
 def ui_effect(

ex4nicegui/utils/clientScope.py

@@ -34,14 +34,11 @@ class NgClientScopeManager:
         if client.id not in self._client_scope_map:
             self._client_scope_map[client.id] = NgScopeSuite()
 
-            # shared clients always not dispose their scope
-            if not client.shared:
-
-                @client.on_disconnect
-                def _(e: Client):
-                    if e.id in self._client_scope_map:
-                        self._client_scope_map[e.id]._top_scope.dispose()  # type: ignore
-                        del self._client_scope_map[e.id]
+            @client.on_disconnect
+            def _(e: Client):
+                if e.id in self._client_scope_map:
+                    self._client_scope_map[e.id]._top_scope.dispose()  # type: ignore
+                    del self._client_scope_map[e.id]
 
         return self._client_scope_map[client.id]
 

ex4nicegui/utils/effect.py

@@ -47,8 +47,7 @@ def effect(
     priority_level=1,
     debug_trigger: Optional[Callable] = None,
     debug_name: Optional[str] = None,
-) -> signe.Effect[None]:
-    ...
+) -> signe.Effect[None]: ...
 
 
 def effect(

ex4nicegui/utils/page_state.py

@@ -0,0 +1,70 @@
+from typing import ClassVar
+from typing_extensions import Self
+from contextvars import ContextVar
+
+
+class PageState:
+    """
+    A base class for defining per-page reactive state containers.
+
+    Each subclass of `PageState` provides an isolated state context that is automatically
+    managed through a `ContextVar`. When used inside different `ui.page` definitions,
+    each page will maintain its own independent instance of the subclass, ensuring
+    states do not interfere across pages.
+
+    Subclasses should define reactive variables (e.g., created via `to_ref`) within
+    their `__init__` method. The instance can then be accessed anywhere in the same
+    page context using `MyState.get()` — without needing to pass it through function parameters.
+
+    Typical use cases include sharing state across multiple components or functions
+    within the same page.
+
+    @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#PageState
+    @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#PageState
+
+    # Example:
+    .. code-block:: python
+        from ex4nicegui import rxui, to_ref, PageState
+        from nicegui import ui
+
+        class MyState(PageState):
+            def __init__(self):
+                self.a = to_ref(1.0)
+
+        def sub_view():
+            state = MyState.get()
+            rxui.label(lambda: f"{state.a.value=}")
+
+        @ui.page('/')
+        def _():
+            state = MyState.get()
+            rxui.number(value=state.a)
+            sub_view()
+    """
+
+    _ctx: ClassVar[ContextVar["PageState"]]
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls._ctx = ContextVar(f"{cls.__name__}_ctx")
+
+    @classmethod
+    def get(cls) -> Self:
+        """
+        Retrieves the current instance of the page state for this subclass.
+
+        If no instance exists yet in the current context, a new one is created
+        and stored. Subsequent calls within the same page will return the same instance.
+
+        This method allows components and functions within the same page
+        to share reactive state seamlessly without passing references explicitly.
+
+        Returns:
+            Self: The current `PageState` subclass instance associated with this page.
+        """
+        inst = cls._ctx.get(None)
+
+        if inst is None:
+            inst = cls()
+            cls._ctx.set(inst)
+        return inst  # type: ignore

ex4nicegui/utils/proxy/descriptor.py

@@ -7,7 +7,6 @@ from .string import StringProxy
 from .float import FloatProxy
 from .bool import BoolProxy
 from .date import DateProxy
-from .dict import DictProxy
 from ex4nicegui.utils.signals import deep_ref
 import datetime
 import warnings

ex4nicegui/utils/refComputed.py

@@ -64,8 +64,7 @@ def ref_computed(
     debug_trigger: Optional[Callable[..., None]] = None,
     priority_level: int = 1,
     debug_name: Optional[str] = None,
-) -> Callable[[Callable[..., T]], ReadonlyRef[T]]:
-    ...
+) -> Callable[[Callable[..., T]], ReadonlyRef[T]]: ...
 
 
 def ref_computed(