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

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)

ex4nicegui/utils/proxy/float.py

@@ -0,0 +1,153 @@
+import sys
+from typing import Any, Optional, SupportsIndex, Tuple, overload
+from . import utils
+from .base import Proxy
+
+
+class FloatProxy(Proxy):
+    # def __new__(cls, value):
+    #     return super().__new__(cls, value)
+
+    def __init__(self, value: float):
+        from ex4nicegui.utils.signals import to_ref
+
+        self._ref = to_ref(value)
+
+    def __str__(self) -> str:
+        return str(self._ref.value)
+
+    def as_integer_ratio(self) -> Tuple[int, int]:
+        return self._ref.value.as_integer_ratio()
+
+    def hex(self) -> str:
+        return self._ref.value.hex()
+
+    def is_integer(self) -> bool:
+        return self._ref.value.is_integer()
+
+    @property
+    def real(self) -> float:
+        return self._ref.value.real
+
+    @property
+    def imag(self) -> float:
+        return self._ref.value.imag
+
+    def conjugate(self) -> float:
+        return self._ref.value.conjugate()
+
+    def __add__(self, value: float, /) -> float:
+        return self._ref.value.__add__(float(utils.to_value(value)))
+
+    def __sub__(self, value: float, /) -> float:
+        return self._ref.value.__sub__(float(utils.to_value(value)))
+
+    def __mul__(self, value: float, /) -> float:
+        return self._ref.value.__mul__(float(utils.to_value(value)))
+
+    def __floordiv__(self, value: float, /) -> float:
+        return self._ref.value.__floordiv__(float(utils.to_value(value)))
+
+    def __truediv__(self, value: float, /) -> float:
+        return self._ref.value.__truediv__(float(utils.to_value(value)))
+
+    def __mod__(self, value: float, /) -> float:
+        return self._ref.value.__mod__(float(utils.to_value(value)))
+
+    def __divmod__(self, value: float, /) -> Tuple[float, float]:
+        return self._ref.value.__divmod__(float(utils.to_value(value)))
+
+    @overload
+    def __pow__(self, value: int, mod: None = None, /) -> float: ...
+    # positive __value -> float; negative __value -> complex
+    # return type must be Any as `float | complex` causes too many false-positive errors
+    @overload
+    def __pow__(self, value: float, mod: None = None, /) -> Any: ...
+
+    def __pow__(self, value: float, mod: None = None, /) -> Any:
+        return self._ref.value.__pow__(float(utils.to_value(value)), mod)
+
+    def __radd__(self, value: float, /) -> float:
+        return self._ref.value.__radd__(float(utils.to_value(value)))
+
+    def __rsub__(self, value: float, /) -> float:
+        return self._ref.value.__rsub__(float(utils.to_value(value)))
+
+    def __rmul__(self, value: float, /) -> float:
+        return self._ref.value.__rmul__(float(utils.to_value(value)))
+
+    def __rfloordiv__(self, value: float, /) -> float:
+        return self._ref.value.__rfloordiv__(float(utils.to_value(value)))
+
+    def __rtruediv__(self, value: float, /) -> float:
+        return self._ref.value.__rtruediv__(float(utils.to_value(value)))
+
+    def __rmod__(self, value: float, /) -> float:
+        return self._ref.value.__rmod__(float(utils.to_value(value)))
+
+    def __rdivmod__(self, value: float, /) -> Tuple[float, float]:
+        return self._ref.value.__rdivmod__(float(utils.to_value(value)))
+
+    def __rpow__(self, value, mod: None = None, /) -> float:
+        return self._ref.value.__rpow__(float(utils.to_value(value)), mod)  # type: ignore
+
+    def __getnewargs__(self) -> Tuple[float]:
+        return (self._ref.value,)
+
+    def __trunc__(self) -> int:
+        return self._ref.value.__trunc__()
+
+    if sys.version_info >= (3, 9):
+
+        def __ceil__(self) -> int:
+            return self._ref.value.__ceil__()
+
+        def __floor__(self) -> int:
+            return self._ref.value.__floor__()
+
+    @overload
+    def __round__(self, ndigits: None = None, /) -> int: ...
+    @overload
+    def __round__(self, ndigits: SupportsIndex, /) -> float: ...
+
+    def __round__(self, ndigits: Optional[SupportsIndex] = None, /):
+        return self._ref.value.__round__(ndigits)
+
+    def __eq__(self, value: object, /) -> bool:
+        return self._ref.value.__eq__(float(utils.to_value(value)))
+
+    def __ne__(self, value: object, /) -> bool:
+        return self._ref.value.__ne__(float(utils.to_value(value)))
+
+    def __lt__(self, value: float, /) -> bool:
+        return self._ref.value.__lt__(float(utils.to_value(value)))
+
+    def __le__(self, value: float, /) -> bool:
+        return self._ref.value.__le__(float(utils.to_value(value)))
+
+    def __gt__(self, value: float, /) -> bool:
+        return self._ref.value.__gt__(float(utils.to_value(value)))
+
+    def __ge__(self, value: float, /) -> bool:
+        return self._ref.value.__ge__(float(utils.to_value(value)))
+
+    def __neg__(self) -> float:
+        return self._ref.value.__neg__()
+
+    def __pos__(self) -> float:
+        return self._ref.value.__pos__()
+
+    def __int__(self) -> int:
+        return self._ref.value.__int__()
+
+    def __float__(self) -> float:
+        return self._ref.value.__float__()
+
+    def __abs__(self) -> float:
+        return self._ref.value.__abs__()
+
+    def __hash__(self) -> int:
+        return self._ref.value.__hash__()
+
+    def __bool__(self) -> bool:
+        return self._ref.value.__bool__()