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

ex4nicegui/utils/proxy/int.py

@@ -0,0 +1,223 @@
+from __future__ import annotations
+from typing import (
+    Literal,
+    Optional,
+    SupportsIndex,
+    Tuple,
+    Union,
+)
+import sys
+from . import utils
+from .base import Proxy
+
+
+class IntProxy(Proxy):
+    # def __new__(cls, value):
+    #     return super().__new__(cls, value)
+
+    def __init__(self, value: int):
+        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, Literal[1]]:
+        return self._ref.value.as_integer_ratio()
+
+    @property
+    def real(self) -> int:
+        return self._ref.value.real
+
+    @property
+    def imag(self) -> Literal[0]:
+        return 0
+
+    @property
+    def numerator(self) -> int:
+        return self._ref.value.numerator
+
+    @property
+    def denominator(self) -> Literal[1]:
+        return 1
+
+    def conjugate(self) -> int:
+        return self._ref.value.conjugate()
+
+    def bit_length(self) -> int:
+        return self._ref.value.bit_length()
+
+    if sys.version_info >= (3, 10):
+
+        def bit_count(self) -> int:
+            return self._ref.value.bit_count()
+
+    if sys.version_info >= (3, 11):
+
+        def to_bytes(
+            self,
+            length: SupportsIndex = 1,
+            byteorder: Literal["little", "big"] = "big",
+            *,
+            signed: bool = False,
+        ) -> bytes:
+            return self._ref.value.to_bytes(length, byteorder, signed=signed)
+
+    else:
+
+        def to_bytes(
+            self,
+            length: SupportsIndex,
+            byteorder: Literal["little", "big"],
+            *,
+            signed: bool = False,
+        ) -> bytes:
+            return self._ref.value.to_bytes(length, byteorder, signed=signed)
+
+    if sys.version_info >= (3, 12):
+
+        def is_integer(self) -> Literal[True]:
+            return True
+
+    def __add__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__add__(int(utils.to_value(value)))
+
+    def __sub__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__sub__(int(utils.to_value(value)))
+
+    def __mul__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__mul__(int(utils.to_value(value)))
+
+    def __floordiv__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__floordiv__(int(utils.to_value(value)))
+
+    def __truediv__(self, value: Union[int, IntProxy]) -> float:
+        return self._ref.value.__truediv__(int(utils.to_value(value)))
+
+    def __mod__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__mod__(int(utils.to_value(value)))
+
+    def __divmod__(self, value: Union[int, IntProxy]) -> Tuple[int, int]:
+        return self._ref.value.__divmod__(int(utils.to_value(value)))
+
+    def __radd__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__radd__(int(utils.to_value(value)))
+
+    def __rsub__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rsub__(int(utils.to_value(value)))
+
+    def __rmul__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rmul__(int(utils.to_value(value)))
+
+    def __rfloordiv__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rfloordiv__(int(utils.to_value(value)))
+
+    def __rtruediv__(self, value: Union[int, IntProxy]) -> float:
+        return self._ref.value.__rtruediv__(int(utils.to_value(value)))
+
+    def __rmod__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rmod__(int(utils.to_value(value)))
+
+    def __rdivmod__(self, value: Union[int, IntProxy]) -> Tuple[int, int]:
+        return self._ref.value.__rdivmod__(int(utils.to_value(value)))
+
+    def __pow__(
+        self, value: Union[int, IntProxy], mod: Optional[int] = None
+    ) -> Union[int, float]:
+        return self._ref.value.__pow__(int(utils.to_value(value)), mod)
+
+    def __rpow__(
+        self, value: Union[int, IntProxy], mod: Optional[int] = None
+    ) -> Union[int, float]:
+        return self._ref.value.__rpow__(int(utils.to_value(value)), mod)
+
+    def __and__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__and__(int(utils.to_value(value)))
+
+    def __or__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__or__(int(utils.to_value(value)))
+
+    def __xor__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__xor__(int(utils.to_value(value)))
+
+    def __lshift__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__lshift__(int(utils.to_value(value)))
+
+    def __rshift__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rshift__(int(utils.to_value(value)))
+
+    def __rand__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rand__(int(utils.to_value(value)))
+
+    def __ror__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__ror__(int(utils.to_value(value)))
+
+    def __rxor__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rxor__(int(utils.to_value(value)))
+
+    def __rlshift__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rlshift__(int(utils.to_value(value)))
+
+    def __rrshift__(self, value: Union[int, IntProxy]) -> int:
+        return self._ref.value.__rrshift__(int(utils.to_value(value)))
+
+    def __neg__(self) -> int:
+        return self._ref.value.__neg__()
+
+    def __pos__(self) -> int:
+        return self._ref.value.__pos__()
+
+    def __invert__(self) -> int:
+        return self._ref.value.__invert__()
+
+    def __trunc__(self) -> int:
+        return self._ref.value.__trunc__()
+
+    def __ceil__(self) -> int:
+        return self._ref.value.__ceil__()
+
+    def __floor__(self) -> int:
+        return self._ref.value.__floor__()
+
+    def __round__(self, ndigits: SupportsIndex = 0) -> int:
+        return self._ref.value.__round__(ndigits)
+
+    def __getnewargs__(self) -> Tuple[int]:
+        return self._ref.value.__getnewargs__()
+
+    def __eq__(self, value: object) -> bool:
+        return self._ref.value.__eq__(int(utils.to_value(value)))
+
+    def __ne__(self, value: object) -> bool:
+        return self._ref.value.__ne__(int(utils.to_value(value)))
+
+    def __lt__(self, value) -> bool:
+        return self._ref.value.__lt__(int(utils.to_value(value)))
+
+    def __le__(self, value) -> bool:
+        return self._ref.value.__le__(int(utils.to_value(value)))
+
+    def __gt__(self, value) -> bool:
+        return self._ref.value.__gt__(int(utils.to_value(value)))
+
+    def __ge__(self, value) -> bool:
+        return self._ref.value.__ge__(int(utils.to_value(value)))
+
+    def __float__(self) -> float:
+        return self._ref.value.__float__()
+
+    def __int__(self) -> int:
+        return self._ref.value.__int__()
+
+    def __abs__(self) -> int:
+        return self._ref.value.__abs__()
+
+    def __hash__(self) -> int:
+        return self._ref.value.__hash__()
+
+    def __bool__(self) -> bool:
+        return self._ref.value.__bool__()
+
+    def __index__(self) -> int:
+        return self._ref.value.__index__()

ex4nicegui/utils/proxy/list.py

@@ -0,0 +1,147 @@
+import sys
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    Iterator,
+    List,
+    SupportsIndex,
+    TypeVar,
+    Generic,
+    Union,
+    overload,
+)
+from typing_extensions import Self
+from . import utils
+from .base import Proxy
+
+
+_T = TypeVar("_T")
+_S = TypeVar("_S")
+
+
+class ListProxy(Proxy, list, Generic[_T]):
+    def __init__(self, value: List[_T]):
+        from ex4nicegui.utils.signals import deep_ref
+
+        super().__init__(value)
+        self._ref = deep_ref(value)
+
+    def copy(self) -> List:
+        return self._ref.value.copy()
+
+    def append(self, object: _T, /) -> None:
+        self._ref.value.append(object)
+
+    def extend(self, iterable: Iterable[_T], /) -> None:
+        self._ref.value.extend(iterable)
+
+    def pop(self, index: SupportsIndex = -1, /) -> _T:
+        return self._ref.value.pop(index)
+
+    # Signature of `list.index` should be kept in line with `collections.UserList.index()`
+    # and multiprocessing.managers.ListProxy.index()
+    def index(
+        self, value: _T, start: SupportsIndex = 0, stop: SupportsIndex = sys.maxsize, /
+    ) -> int:
+        return self._ref.value.index(value, start, stop)
+
+    def count(self, value: _T, /) -> int:
+        return self._ref.value.count(value)
+
+    def insert(self, index: SupportsIndex, object: _T, /) -> None:
+        self._ref.value.insert(index, object)
+
+    def remove(self, value: _T, /) -> None:
+        self._ref.value.remove(value)
+
+    def reverse(self) -> None:
+        return self._ref.value.reverse()
+
+    # Signature of `list.sort` should be kept inline with `collections.UserList.sort()`
+    # and multiprocessing.managers.ListProxy.sort()
+    #
+    # Use List[SupportsRichComparisonT] for the first overload rather than [SupportsRichComparison]
+    # to work around invariance
+    @overload
+    def sort(self: list, *, key: None = None, reverse: bool = False) -> None: ...
+    @overload
+    def sort(self, *, key: Callable[[_T], Any], reverse: bool = False) -> None: ...
+
+    def sort(
+        self, *, key: Union[Callable[[_T], Any], None] = None, reverse: bool = False
+    ) -> None:
+        self._ref.value.sort(key=key, reverse=reverse)  # type: ignore
+
+    def __len__(self) -> int:
+        return len(self._ref.value)
+
+    def __iter__(self) -> Iterator[_T]:
+        return iter(self._ref.value)
+
+    @overload
+    def __getitem__(self, i: SupportsIndex, /) -> _T: ...
+    @overload
+    def __getitem__(self, s: slice, /) -> List[_T]: ...
+
+    def __getitem__(self, i: Union[SupportsIndex, slice], /) -> Union[_T, List[_T]]:
+        return self._ref.value.__getitem__(i)
+
+    @overload
+    def __setitem__(self, key: SupportsIndex, value: _T, /) -> None: ...
+    @overload
+    def __setitem__(self, key: slice, value: Iterable[_T], /) -> None: ...
+
+    def __setitem__(
+        self, key: Union[SupportsIndex, slice], value: Union[_T, Iterable[_T]], /
+    ) -> None:
+        self._ref.value.__setitem__(key, value)
+
+    def __delitem__(self, key: Union[SupportsIndex, slice], /) -> None:
+        self._ref.value.__delitem__(key)
+
+    # Overloading looks unnecessary, but is needed to work around complex mypy problems
+    @overload
+    def __add__(self, value: List[_T], /) -> List[_T]: ...
+    @overload
+    def __add__(self, value: List[_S], /) -> List[Union[_S, _T]]: ...
+
+    def __add__(
+        self, value: Union[List[_T], List[_S]], /
+    ) -> Union[List[_T], List[Union[_S, _T]]]:
+        return self._ref.value.__add__(utils.to_value(value))
+
+    def __iadd__(self, value: Iterable[_T], /) -> Self:  # type: ignore[misc]
+        self._ref.value.__iadd__(utils.to_value(value))
+        return self
+
+    def __mul__(self, value: SupportsIndex, /) -> List[_T]:
+        return self._ref.value.__mul__(utils.to_value(value))
+
+    def __rmul__(self, value: SupportsIndex, /) -> List[_T]:
+        return self._ref.value.__rmul__(utils.to_value(value))
+
+    def __imul__(self, value: SupportsIndex, /) -> Self:
+        self._ref.value.__imul__(utils.to_value(value))
+        return self
+
+    def __contains__(self, key: object, /) -> bool:
+        return self._ref.value.__contains__(key)
+
+    def __reversed__(self) -> Iterator[_T]:
+        return self._ref.value.__reversed__()
+
+    def __gt__(self, value: List[_T], /) -> bool:
+        return self._ref.value.__gt__(utils.to_value(value))
+
+    def __ge__(self, value: List[_T], /) -> bool:
+        return self._ref.value.__ge__(utils.to_value(value))
+
+    def __lt__(self, value: List[_T], /) -> bool:
+        return self._ref.value.__lt__(utils.to_value(value))
+
+    def __le__(self, value: List[_T], /) -> bool:
+        return self._ref.value.__le__(utils.to_value(value))
+
+    def __eq__(self, value: object, /) -> bool:
+        return self._ref.value.__eq__(utils.to_value(value))