ex4nicegui 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

ex4nicegui/reactive/officials/tab_panels.py

@@ -10,9 +10,10 @@ from ex4nicegui.utils.signals import (
 from ex4nicegui.utils.scheduler import next_tick
 from nicegui import ui, background_tasks, core
 from .base import BindableUi
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
-class TabPanelsBindableUi(BindableUi[ui.tab_panels]):
+class TabPanelsBindableUi(BindableUi[ui.tab_panels], ValueElementMixin[bool]):
     def __init__(
         self,
         value: Optional[TMaybeRef[str]] = None,
@@ -50,16 +51,11 @@ class TabPanelsBindableUi(BindableUi[ui.tab_panels]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))
-
 
 class lazy_tab_panel(ui.tab_panel):
     def __init__(self, name: str) -> None:

ex4nicegui/reactive/officials/tabs.py

@@ -2,14 +2,14 @@ from typing import Any, Callable, Optional
 from ex4nicegui.reactive.services.reactive_service import ParameterClassifier
 from ex4nicegui.utils.signals import (
     TGetterOrReadonlyRef,
-    to_value,
     _TMaybeRef as TMaybeRef,
 )
 from nicegui import ui
 from .base import BindableUi
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
-class TabsBindableUi(BindableUi[ui.tabs]):
+class TabsBindableUi(BindableUi[ui.tabs], ValueElementMixin[str]):
     def __init__(
         self,
         value: Optional[TMaybeRef[str]] = None,
@@ -33,12 +33,7 @@ class TabsBindableUi(BindableUi[ui.tabs]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
-
-    def bind_value(self, value: TGetterOrReadonlyRef):
-        @self._ui_effect
-        def _():
-            self.element.set_value(to_value(value))

ex4nicegui/reactive/officials/textarea.py

@@ -16,9 +16,10 @@ from ex4nicegui.utils.signals import (
 from nicegui import ui
 from nicegui.events import handle_event
 from .base import BindableUi
+from ex4nicegui.reactive.mixins.value_element import ValueElementMixin
 
 
-class TextareaBindableUi(BindableUi[ui.textarea]):
+class TextareaBindableUi(BindableUi[ui.textarea], ValueElementMixin[str]):
     def __init__(
         self,
         label: Optional[TMaybeRef[str]] = None,
@@ -26,7 +27,7 @@ class TextareaBindableUi(BindableUi[ui.textarea]):
         placeholder: Optional[TMaybeRef[str]] = None,
         value: TMaybeRef[str] = "",
         on_change: Optional[Callable[..., Any]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[Dict[str, Callable[..., bool]]] = None,
     ) -> None:
         pc = ParameterClassifier(
             locals(),
@@ -53,18 +54,11 @@ class TextareaBindableUi(BindableUi[ui.textarea]):
         return self.element.value
 
     def bind_prop(self, prop: str, value: TGetterOrReadonlyRef):
-        if prop == "value":
-            return self.bind_value(value)
+        if ValueElementMixin._bind_specified_props(self, prop, value):
+            return self
 
         return super().bind_prop(prop, value)
 
-    def bind_value(self, value: TGetterOrReadonlyRef[str]):
-        @self._ui_signal_on(value)
-        def _():
-            self.element.set_value(to_value(value))
-
-        return self
-
 
 class LazyTextareaBindableUi(TextareaBindableUi):
     def __init__(
@@ -74,7 +68,7 @@ class LazyTextareaBindableUi(TextareaBindableUi):
         placeholder: Optional[TMaybeRef[str]] = None,
         value: TMaybeRef[str] = "",
         on_change: Optional[Callable[..., Any]] = None,
-        validation: Dict[str, Callable[..., bool]] = {},
+        validation: Optional[Dict[str, Callable[..., bool]]] = None,
     ) -> None:
         org_value = value
         is_setter_value = is_setter_ref(value)

ex4nicegui/reactive/services/reactive_service.py

@@ -15,6 +15,7 @@ from ex4nicegui.reactive.systems.reactive_system import (
     convert_kws_ref2value,
     inject_method,
 )
+from ex4nicegui.utils.proxy import is_base_type_proxy
 
 
 class ParameterClassifier:
@@ -34,7 +35,7 @@ class ParameterClassifier:
             exclude.append(extend_kws)
 
         self._args: Dict[str, Any] = {
-            k: v
+            k: v._ref if is_base_type_proxy(v) else v
             for k, v in args.items()
             if k != "self" and k[0] != "_" and (k not in exclude)
         }

ex4nicegui/reactive/vfor.py

@@ -28,6 +28,8 @@ from dataclasses import dataclass
 from signe.core.scope import Scope
 from ex4nicegui.reactive.systems.object_system import get_attribute
 from ex4nicegui.reactive.empty import Empty
+from ex4nicegui.utils.proxy import to_ref_if_base_type_proxy
+
 
 _T = TypeVar("_T")
 _T_data = Union[List[Any], TGetterOrReadonlyRef[List[Any]], RefWrapper]
@@ -178,6 +180,8 @@ class vfor(Generic[_T]):
         *,
         key: Optional[Union[str, Callable[[int, Any], Any]]] = None,
     ) -> None:
+        data = to_ref_if_base_type_proxy(data)
+
         self._data = to_ref_wrapper(lambda: data) if is_reactive(data) else data
         self._get_key = vfor.index_key
         self._transition_props = {}

ex4nicegui/reactive/view_model.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Callable, Union, Type, TypeVar
+from typing import Any, Callable, List, Optional, Union, Type, TypeVar, overload
 from ex4nicegui.utils.signals import (
     deep_ref,
     is_ref,
@@ -13,8 +13,16 @@ from ex4nicegui.utils.signals import (
 from ex4nicegui.utils.types import ReadonlyRef
 from functools import partial
 from signe.core.reactive import NoProxy
+from ex4nicegui.utils.proxy.descriptor import class_var_setter
+from ex4nicegui.utils.proxy.bool import BoolProxy
+from ex4nicegui.utils.proxy.int import IntProxy
+from ex4nicegui.utils.proxy.float import FloatProxy
+from ex4nicegui.utils.proxy.base import Proxy
+from ex4nicegui.utils.proxy import to_value_if_base_type_proxy
+from ex4nicegui.utils.proxy.descriptor import ProxyDescriptor
 
 _CACHED_VARS_FLAG = "__vm_cached__"
+_LIST_VAR_FLAG = "__vm_list_var__"
 
 _T = TypeVar("_T")
 
@@ -31,15 +39,30 @@ class ViewModel(NoProxy):
         from ex4nicegui import rxui
 
         class MyVm(rxui.ViewModel):
-            count = rxui.var(0)
-            data = rxui.var(lambda: [1,2,3])
+            count = 0
+            data = []
+            nums = rxui.list_var(lambda: [1, 2, 3])
+
+            def __init__(self):
+                super().__init__()
+                self.data = [1, 2, 3]
+
+            def increment(self):
+                self.count += 1
+
+            def add_data(self):
+                self.data.append(4)
+
 
         vm = MyVm()
 
         rxui.label(vm.count)
         rxui.number(value=vm.count)
 
-
+        ui.button("Increment", on_click=vm.increment)
+        ui.button("Add Data", on_click=vm.add_data)
+        rxui.label(vm.data)
+        rxui.label(vm.nums)
     """
 
     def __init__(self):
@@ -49,8 +72,86 @@ class ViewModel(NoProxy):
             if callable(value) and hasattr(value, _CACHED_VARS_FLAG):
                 setattr(self, name, computed(partial(value, self)))
 
+    def __init_subclass__(cls) -> None:
+        need_vars = (
+            (name, value)
+            for name, value in vars(cls).items()
+            if not name.startswith("_")
+        )
+
+        for name, value in need_vars:
+            class_var_setter(cls, name, value, _LIST_VAR_FLAG)
+
+    @overload
+    @staticmethod
+    def on_refs_changed(vm: ViewModel): ...
+
+    @overload
+    @staticmethod
+    def on_refs_changed(
+        vm: ViewModel, callback: Optional[Callable[[], Any]] = None
+    ): ...
+
+    @staticmethod
+    def on_refs_changed(vm: ViewModel, callback: Optional[Callable[[], Any]] = None):
+        if callback is None:
+
+            def wrapper(fn: Callable[[], Any]):
+                return ViewModel.on_refs_changed(vm, fn)
+
+            return wrapper
+
+        refs = ViewModel.get_refs(vm)
+
+        @on(refs, onchanges=True, deep=False)
+        def _():
+            callback()
+
+    @staticmethod
+    def get_refs(vm: ViewModel):
+        """Get all the refs of a ViewModel.
+
+        Args:
+            vm (ViewModel): The ViewModel to get refs from.
+
+
+        """
+        var_names = [
+            name
+            for name, value in vm.__class__.__dict__.items()
+            if isinstance(value, ProxyDescriptor)
+        ]
+
+        return [getattr(vm, name) for name in var_names]
+
+    @staticmethod
+    def to_value(value: Union[ViewModel, Proxy, List, dict]):
+        """Convert a ViewModel, Proxy, List, or dict to a value.
+
+        Args:
+            value (Union[ViewModel, Proxy, List, dict]):  The value to convert.
+
+        """
+        if isinstance(value, list):
+            return [ViewModel.to_value(v) for v in value]
+
+        if isinstance(value, dict):
+            return {k: ViewModel.to_value(v) for k, v in value.items()}
+
+        if isinstance(value, ViewModel):
+            return {
+                k: ViewModel.to_value(v)
+                for k, v in value.__dict__.items()
+                if not k.startswith("_")
+            }
+
+        if isinstance(value, Proxy):
+            return to_value_if_base_type_proxy(value)
+
+        return value
+
     @staticmethod
-    def display(model: Union[ViewModel, Type]):
+    def _display(model: Union[ViewModel, Type]):
         result = to_ref("")
 
         watch_refs = _recursive_to_refs(model)
@@ -67,6 +168,18 @@ class ViewModel(NoProxy):
 
         return result
 
+    @staticmethod
+    def is_bool(value: Any):
+        return isinstance(value, bool) or isinstance(value, BoolProxy)
+
+    @staticmethod
+    def is_int(value: Any):
+        return isinstance(value, int) or isinstance(value, IntProxy)
+
+    @staticmethod
+    def is_float(value: Any):
+        return isinstance(value, float) or isinstance(value, FloatProxy)
+
 
 def _recursive_to_value(value_or_model):
     value = to_raw(to_value(value_or_model))
@@ -139,6 +252,34 @@ def var(value: Union[_T_Var_Value, Callable[[], _T_Var_Value]]) -> Ref[_T_Var_Va
     return deep_ref(value)
 
 
+def list_var(factory: Callable[[], List[_T_Var_Value]]) -> List[_T_Var_Value]:
+    """Create implicitly proxied reactive variables for lists. Use them just like ordinary lists while maintaining reactivity. Only use within rxui.ViewModel.
+
+    Args:
+        factory (Callable[[], List[_T_Var_Value]]): A factory function that returns a new list.
+
+    Example:
+    .. code-block:: python
+        from ex4nicegui import rxui
+        class State(rxui.ViewModel):
+            data = rxui.list_var(lambda: [1, 2, 3])
+
+            def append_data(self):
+                self.data.append(len(self.data) + 1)
+
+            def display_data(self):
+                return ",".join(map(str, self.data))
+
+        state = State()
+        ui.button("Append", on_click=state.append_data)
+        rxui.label(state.display_data)
+
+    """
+    assert callable(factory), "factory must be a callable"
+    setattr(factory, _LIST_VAR_FLAG, None)
+    return factory  # type: ignore
+
+
 def cached_var(func: Callable[..., _T]) -> ReadonlyRef[_T]:
     """A decorator to cache the result of a function. Only use within rxui.ViewModel.
 
@@ -149,7 +290,7 @@ def cached_var(func: Callable[..., _T]) -> ReadonlyRef[_T]:
     .. code-block:: python
         from ex4nicegui import rxui
         class MyVm(rxui.ViewModel):
-            name = rxui.var("John")
+            name = "John"
 
             @rxui.cached_var
             def uppper_name(self):

ex4nicegui/utils/proxy/__init__.py

@@ -0,0 +1,19 @@
+from .base import Proxy
+
+
+def is_base_type_proxy(obj):
+    return isinstance(obj, Proxy)
+
+
+def to_ref_if_base_type_proxy(obj):
+    if is_base_type_proxy(obj):
+        return obj._ref
+    else:
+        return obj
+
+
+def to_value_if_base_type_proxy(obj):
+    if is_base_type_proxy(obj):
+        return obj._ref.value
+    else:
+        return obj

ex4nicegui/utils/proxy/base.py

@@ -0,0 +1,9 @@
+from typing import Any, Protocol
+
+
+class ProxyProtocol(Protocol):
+    _ref: Any
+
+
+class Proxy(ProxyProtocol):
+    pass

ex4nicegui/utils/proxy/bool.py

@@ -0,0 +1,58 @@
+from typing import Tuple
+from . import utils
+from .base import Proxy
+
+
+class BoolProxy(Proxy):
+    def __init__(self, value: bool):
+        from ex4nicegui.utils.signals import to_ref
+
+        if isinstance(value, (bool, int)):
+            self._ref = to_ref(value)
+        else:
+            raise ValueError("only accepts boolean or integer values")
+
+    def __bool__(self):
+        return self._ref.value
+
+    def __str__(self):
+        return str(self._ref.value)
+
+    def __eq__(self, other):
+        return self._ref.value.__eq__(utils.to_value(other))
+
+    def __ne__(self, other):
+        return self._ref.value.__ne__(utils.to_value(other))
+
+    def __lt__(self, value) -> bool:
+        return self._ref.value.__lt__(bool(utils.to_value(value)))
+
+    def __le__(self, value) -> bool:
+        return self._ref.value.__le__(bool(utils.to_value(value)))
+
+    def __gt__(self, value) -> bool:
+        return self._ref.value.__gt__(bool(utils.to_value(value)))
+
+    def __ge__(self, value) -> bool:
+        return self._ref.value.__ge__(bool(utils.to_value(value)))
+
+    def __and__(self, other):
+        return self._ref.value.__and__(utils.to_value(other))
+
+    def __or__(self, other):
+        return self._ref.value.__or__(utils.to_value(other))
+
+    def __xor__(self, other):
+        return self._ref.value.__xor__(utils.to_value(other))
+
+    def __rand__(self, value: bool, /) -> bool:
+        return self._ref.value.__rand__(value)
+
+    def __ror__(self, value: bool, /) -> bool:
+        return self._ref.value.__ror__(value)
+
+    def __rxor__(self, value: bool, /) -> bool:
+        return self._ref.value.__rxor__(value)
+
+    def __getnewargs__(self) -> Tuple[int]:
+        return (int(self._ref.value),)

ex4nicegui/utils/proxy/date.py

@@ -0,0 +1,88 @@
+from . import utils
+import datetime
+from .base import Proxy
+
+
+class DateProxy(Proxy, datetime.date):
+    def __new__(cls, year, month=None, day=None):
+        return super().__new__(cls, year, month, day)
+
+    def __init__(self, year, month, day):
+        from ex4nicegui.utils.signals import to_ref
+
+        self._ref = to_ref(datetime.date(year, month, day))
+
+    def __str__(self):
+        return str(self._ref.value)
+
+    def ctime(self):
+        return self._ref.value.ctime()
+
+    def strftime(self, fmt):
+        return self._ref.value.strftime(fmt)
+
+    def __format__(self, fmt):
+        return self._ref.value.__format__(fmt)
+
+    def isoformat(self):
+        return self._ref.value.isoformat()
+
+    @property
+    def year(self):
+        return self._ref.value.year
+
+    @property
+    def month(self):
+        return self._ref.value.month
+
+    @property
+    def day(self):
+        return self._ref.value.day
+
+    def timetuple(self):
+        return self._ref.value.timetuple()
+
+    def toordinal(self):
+        return self._ref.value.toordinal()
+
+    def replace(self, year=None, month=None, day=None):
+        return self._ref.value.replace(year=year, month=month, day=day)
+
+    def __eq__(self, other):
+        return self._ref.value.__eq__(utils.to_value(other))
+
+    def __le__(self, other):
+        return self._ref.value.__le__(utils.to_value(other))
+
+    def __lt__(self, other):
+        return self._ref.value.__lt__(utils.to_value(other))
+
+    def __ge__(self, other):
+        return self._ref.value.__ge__(utils.to_value(other))
+
+    def __gt__(self, other):
+        return self._ref.value.__gt__(utils.to_value(other))
+
+    def __hash__(self):
+        return self._ref.value.__hash__()
+
+    def __add__(self, other):
+        return self._ref.value.__add__(utils.to_value(other))
+
+    def __radd__(self, other):
+        return self._ref.value.__radd__(utils.to_value(other))
+
+    def __sub__(self, other):
+        return self._ref.value.__sub__(utils.to_value(other))
+
+    def weekday(self):
+        return self._ref.value.weekday()
+
+    def isoweekday(self):
+        return self._ref.value.isoweekday()
+
+    def isocalendar(self):
+        return self._ref.value.isocalendar()
+
+    def __reduce__(self):
+        return self._ref.value.__reduce__()

ex4nicegui/utils/proxy/descriptor.py

@@ -0,0 +1,126 @@
+import sys
+from typing import Any, Callable, Dict, List, Optional, Type, TypeVar, Generic
+from .base import ProxyProtocol
+from .int import IntProxy
+from .list import ListProxy
+from .string import StringProxy
+from .float import FloatProxy
+from .bool import BoolProxy
+from .date import DateProxy
+from .dict import DictProxy
+import datetime
+import warnings
+from . import to_value_if_base_type_proxy
+
+T = TypeVar("T")
+
+
+class ProxyDescriptor(Generic[T]):
+    def __init__(
+        self,
+        name: str,
+        value: T,
+        proxy_builder: Callable[[T], ProxyProtocol],
+        proxy_rebuilder: Optional[Callable[[ProxyProtocol], ProxyProtocol]] = None,
+    ) -> None:
+        self.value = value
+        self.name = name
+        self._proxy_builder = proxy_builder
+        self._proxy_rebuilder = proxy_rebuilder
+
+    def __get__(self, instance: object, owner: Any):
+        if instance is None:
+            return self
+
+        proxy = instance.__dict__.get(self.name, None)
+        if proxy is None:
+            proxy = self._proxy_builder(self.value)
+            instance.__dict__[self.name] = proxy
+        else:
+            proxy = self._proxy_rebuilder(proxy) if self._proxy_rebuilder else proxy
+        proxy._ref.value  # type: ignore
+        return proxy
+
+    def __set__(self, instance: object, value: T) -> None:
+        value = to_value_if_base_type_proxy(value)
+        proxy = instance.__dict__.get(self.name, None)
+        if proxy is None:
+            proxy = self._proxy_builder(value)  # type: ignore
+            instance.__dict__[self.name] = proxy
+
+        proxy._ref.value = value  # type: ignore
+
+
+class IntDescriptor(ProxyDescriptor[int]):
+    def __init__(self, name: str, value: int) -> None:
+        super().__init__(name, value, IntProxy)
+
+
+class ListDescriptor(ProxyDescriptor[Callable[[], List]]):
+    def __init__(self, name: str, value: Callable[[], List]) -> None:
+        super().__init__(name, value, lambda x: ListProxy(x() if callable(x) else x))
+
+
+class DictDescriptor(ProxyDescriptor[Dict]):
+    def __init__(self, name: str, value: Dict) -> None:
+        super().__init__(name, value, DictProxy)
+
+
+class StringDescriptor(ProxyDescriptor[str]):
+    def __init__(self, name: str, value: str) -> None:
+        def rebuild_proxy(proxy: ProxyProtocol) -> ProxyProtocol:
+            sp = StringProxy(proxy._ref.value)
+            sp._ref = proxy._ref
+            return sp
+
+        super().__init__(name, value, StringProxy, rebuild_proxy)
+
+
+class FloatDescriptor(ProxyDescriptor[float]):
+    def __init__(self, name: str, value: float) -> None:
+        super().__init__(name, value, FloatProxy)
+
+
+class BoolDescriptor(ProxyDescriptor[bool]):
+    def __init__(self, name: str, value: bool) -> None:
+        super().__init__(name, value, BoolProxy)
+
+
+class DateDescriptor(ProxyDescriptor[datetime.date]):
+    def __init__(self, name: str, value: datetime.date) -> None:
+        super().__init__(name, value, lambda x: DateProxy(x.year, x.month, x.day))
+
+
+def class_var_setter(cls: Type, name: str, value, list_var_flat: str) -> None:
+    if value is None or isinstance(value, str):
+        setattr(cls, name, StringDescriptor(name, value))
+    elif isinstance(value, bool):
+        setattr(cls, name, BoolDescriptor(name, value))
+    elif isinstance(value, int):
+        setattr(cls, name, IntDescriptor(name, value))
+    elif callable(value) and hasattr(value, list_var_flat):
+        setattr(cls, name, ListDescriptor(name, value))
+
+    elif isinstance(value, list):
+        if len(value) > 0:
+            with warnings.catch_warnings():
+                warnings.showwarning = _custom_showwarning
+                warnings.warn(
+                    f"The variable [{cls.__name__}.{name}] will be empty list.you should initialize it in the constructor,or use list_var for definition.\n {name} = rxui.list_var(lambda:[1,2,3])",
+                    stacklevel=3,
+                )
+        setattr(cls, name, ListDescriptor(name, lambda: []))
+
+    elif isinstance(value, dict):
+        pass  # TODO
+        # setattr(cls, name, DictDescriptor(name, value))
+    elif isinstance(value, float):
+        setattr(cls, name, FloatDescriptor(name, value))
+    elif isinstance(value, datetime.date):
+        setattr(cls, name, DateDescriptor(name, value))
+    else:
+        pass
+
+
+def _custom_showwarning(message, category, filename, lineno, file=None, line=None):
+    sys.stderr.write(f"{filename}:{lineno}: {category.__name__}: {message}\n")