ex4nicegui 0.8.0__py3-none-any.whl → 0.8.2__py3-none-any.whl

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")

ex4nicegui/utils/proxy/dict.py

@@ -0,0 +1,110 @@
+import sys
+from typing import Dict, Iterator, TypeVar, Generic
+import datetime
+from .string import StringProxy
+from .int import IntProxy
+from .float import FloatProxy
+from .bool import BoolProxy
+from .date import DateProxy
+
+from signe import to_raw
+from ex4nicegui.utils.signals import to_ref_wrapper
+
+
+_KT = TypeVar("_KT")
+_VT = TypeVar("_VT")
+
+
+class DictProxy(dict, Generic[_KT, _VT]):
+    def __init__(self, value: Dict):
+        from ex4nicegui.utils.signals import deep_ref
+
+        super().__init__(value)
+        self._ref = deep_ref(value)
+
+        self.__key_cache = {}
+
+    def copy(self) -> Dict[_KT, _VT]:
+        return to_raw(self._ref.value).copy()
+
+    def keys(self):
+        return to_raw(self._ref.value).keys()
+
+    def values(self):
+        return to_raw(self._ref.value).values()
+
+    def items(self):
+        return to_raw(self._ref.value).items()
+
+    def get(self, key: _KT, default, /):
+        return self._ref.value.get(key, default)
+
+    def pop(self, key: _KT, default, /):
+        return self._ref.value.pop(key, default)
+
+    def __len__(self) -> int:
+        return self._ref.value.__len__()
+
+    def __getitem__(self, key: _KT, /):
+        print("getitem")
+        value = self._ref.value.__getitem__(key)
+
+        if isinstance(value, str):
+            if key not in self.__key_cache:
+                self.__key_cache[key] = StringProxy(value)
+
+            sp = self.__key_cache[key]
+
+            def getter():
+                return to_raw(self._ref.value)[key]
+
+            def setter(v):
+                self._ref.value[key] = v
+
+            sp._ref = to_ref_wrapper(getter, setter)
+
+            return sp
+        elif isinstance(value, int):
+            return IntProxy(value)
+        elif isinstance(value, float):
+            return FloatProxy(value)
+        elif isinstance(value, bool):
+            return BoolProxy(value)
+        elif isinstance(value, datetime.date):
+            return DateProxy(value.year, value.month, value.day)
+        else:
+            pass
+
+        return value
+
+    def __setitem__(self, key: _KT, value: _VT, /) -> None:
+        self._ref.value.__setitem__(key, value)
+
+    def __delitem__(self, key: _KT, /) -> None:
+        self._ref.value.__delitem__(key)
+
+    def __iter__(self) -> Iterator[_KT]:
+        return self._ref.value.__iter__()
+
+    def __eq__(self, value: object, /) -> bool:
+        return self._ref.value.__eq__(value)
+
+    def __reversed__(self) -> Iterator[_KT]:
+        return self._ref.value.__reversed__()
+
+    def __str__(self) -> str:
+        return self._ref.value.__str__()
+
+    def __contains__(self, key: object) -> bool:
+        return self._ref.value.__contains__(key)
+
+    if sys.version_info >= (3, 9):
+
+        def __or__(self, value, /):
+            return self._ref.value.__or__(value)
+
+        def __ror__(self, value, /):
+            return self._ref.value.__ror__(value)
+
+        def __ior__(self, value, /):
+            self._ref.value.update(value)