ex4nicegui 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

ex4nicegui/reactive/{utils.py → services/reactive_service.py}

@@ -5,36 +5,16 @@ from typing import (
     Iterable,
     List,
     Optional,
-    Protocol,
     Tuple,
     cast,
-    runtime_checkable,
-    Union,
 )
-
-from ex4nicegui.utils.signals import is_ref, to_value, is_setter_ref
+from nicegui import ui
+from ex4nicegui.utils.signals import is_ref, is_setter_ref
 from nicegui.events import handle_event
-
-try:
-    import pandas as pd
-except ImportError:
-    pass
-
-
-@runtime_checkable
-class GetItemProtocol(Protocol):
-    def __getitem__(self, key):
-        ...
-
-
-@runtime_checkable
-class SetItemProtocol(Protocol):
-    def __setitem__(self, key, value):
-        ...
-
-
-def _convert_kws_ref2value(kws: Dict) -> Dict:
-    return {key: to_value(value) for key, value in kws.items()}
+from ex4nicegui.reactive.systems.reactive_system import (
+    convert_kws_ref2value,
+    inject_method,
+)
 
 
 class ParameterClassifier:
@@ -75,7 +55,7 @@ class ParameterClassifier:
             )
 
     def get_values_kws(self) -> Dict:
-        value_kws = _convert_kws_ref2value(
+        value_kws = convert_kws_ref2value(
             {k: v for k, v in self._args.items() if k not in self.events}
         )
 
@@ -105,43 +85,5 @@ class ParameterClassifier:
         }
 
 
-def get_attribute(obj: Union[object, GetItemProtocol], name: Union[str, int]) -> Any:
-    if isinstance(obj, (GetItemProtocol)):
-        return obj[name]
-    return getattr(obj, name)  # type: ignore
-
-
-def set_attribute(
-    obj: Union[object, SetItemProtocol], name: Union[str, int], value: Any
-) -> None:
-    if isinstance(obj, SetItemProtocol):
-        obj[name] = value
-    else:
-        setattr(obj, name, value)  # type: ignore
-
-
-def dataframe2col_str(df, copy=True):
-    if isinstance(df.columns, pd.MultiIndex):
-        raise ValueError(
-            "MultiIndex columns are not supported. "
-            "You can convert them to strings using something like "
-            '`df.columns = ["_".join(col) for col in df.columns.values]`.'
-        )
-
-    date_cols = df.columns[df.dtypes == "datetime64[ns]"]
-    time_cols = df.columns[df.dtypes == "timedelta64[ns]"]
-    complex_cols = df.columns[df.dtypes == "complex128"]
-    period_cols = df.columns[df.dtypes == "period[M]"]
-    if (
-        len(date_cols) != 0
-        or len(time_cols) != 0
-        or len(complex_cols) != 0
-        or len(period_cols) != 0
-    ):
-        df = df.copy() if copy else df
-        df[date_cols] = df[date_cols].astype(str)
-        df[time_cols] = df[time_cols].astype(str)
-        df[complex_cols] = df[complex_cols].astype(str)
-        df[period_cols] = df[period_cols].astype(str)
-
-    return df
+def inject_handle_delete(element: ui.element, on_delete: Callable[[], None]):
+    inject_method(element, "_handle_delete", on_delete)

ex4nicegui/reactive/systems/color_system.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from nicegui.elements.mixins.color_elements import (
+    QUASAR_COLORS,
+    TAILWIND_COLORS,
+)
+
+
+_color_system_type = Literal["QUASAR", "TAILWIND", "STYLE"]
+
+
+def get_text_color_info(name: str):
+    system_type: _color_system_type = "STYLE"
+
+    if name in QUASAR_COLORS:
+        system_type = "QUASAR"
+    elif name in TAILWIND_COLORS:
+        system_type = "TAILWIND"
+        name = f"text-{name}"
+    else:
+        pass
+
+    return system_type, name

ex4nicegui/reactive/systems/object_system.py

@@ -0,0 +1,33 @@
+from typing import (
+    Any,
+    Protocol,
+    runtime_checkable,
+    Union,
+)
+
+
+@runtime_checkable
+class GetItemProtocol(Protocol):
+    def __getitem__(self, key):
+        ...
+
+
+@runtime_checkable
+class SetItemProtocol(Protocol):
+    def __setitem__(self, key, value):
+        ...
+
+
+def get_attribute(obj: Union[object, GetItemProtocol], name: Union[str, int]) -> Any:
+    if isinstance(obj, (GetItemProtocol)):
+        return obj[name]
+    return getattr(obj, name)  # type: ignore
+
+
+def set_attribute(
+    obj: Union[object, SetItemProtocol], name: Union[str, int], value: Any
+) -> None:
+    if isinstance(obj, SetItemProtocol):
+        obj[name] = value
+    else:
+        setattr(obj, name, value)  # type: ignore

ex4nicegui/reactive/systems/reactive_system.py

@@ -0,0 +1,21 @@
+from typing import Callable, Dict
+from ex4nicegui.utils.signals import to_value
+
+
+def convert_kws_ref2value(kws: Dict) -> Dict:
+    return {key: to_value(value) for key, value in kws.items()}
+
+
+def inject_method(obj, method_name: str, new_handle: Callable):
+    if hasattr(obj, method_name):
+        original_method = getattr(obj, method_name)
+
+        def injected_method(*args, **kwargs):
+            new_handle(*args, **kwargs)
+            return original_method(*args, **kwargs)
+
+        setattr(obj, method_name, injected_method)
+    else:
+        raise AttributeError(
+            f"'{type(obj).__name__}' object has no attribute '{method_name}'."
+        )

ex4nicegui/reactive/useMouse/UseMouse.py

@@ -4,7 +4,7 @@ from nicegui.dataclasses import KWONLY_SLOTS
 from nicegui.events import handle_event, UiEventArguments
 from nicegui.element import Element
 
-from ex4nicegui.utils.signals import ReadonlyRef, batch, to_ref
+from ex4nicegui.utils.signals import TReadonlyRef, batch, to_ref
 
 _Update_Args = [
     "x",
@@ -42,15 +42,15 @@ class UseMouse(Element, component="UseMouse.js"):
 
     @property
     def x(self):
-        return cast(ReadonlyRef[float], self.__x)
+        return cast(TReadonlyRef[float], self.__x)
 
     @property
     def y(self):
-        return cast(ReadonlyRef[float], self.__y)
+        return cast(TReadonlyRef[float], self.__y)
 
     @property
     def sourceType(self):
-        return cast(ReadonlyRef[float], self.__sourceType)
+        return cast(TReadonlyRef[float], self.__sourceType)
 
     def on_update(self, handler: Optional[Callable[..., Any]]):
         def inner_handler(e):

ex4nicegui/reactive/usePagination.py

@@ -4,7 +4,7 @@ from ex4nicegui.utils.signals import (
     to_ref,
     to_value,
     effect,
-    _TMaybeRef as TMaybeRef,
+    TMaybeRef,
 )
 from typing import Any
 from typing_extensions import Protocol

ex4nicegui/reactive/vfor.py

@@ -26,9 +26,8 @@ from typing import (
 from functools import partial
 from dataclasses import dataclass
 from signe.core.scope import Scope
-from .utils import get_attribute
+from ex4nicegui.reactive.systems.object_system import get_attribute
 from ex4nicegui.reactive.empty import Empty
-# from .transitionGroup import TransitionGroup
 
 _T = TypeVar("_T")
 _T_data = Union[List[Any], TGetterOrReadonlyRef[List[Any]], RefWrapper]

ex4nicegui/reactive/vmodel.py

@@ -25,7 +25,7 @@ import tokenize
 import executing
 import ast
 import warnings
-from .utils import get_attribute, set_attribute
+from ex4nicegui.reactive.systems.object_system import get_attribute, set_attribute
 
 _T = TypeVar("_T")
 

ex4nicegui/utils/refComputed.py

@@ -0,0 +1,147 @@
+from functools import partial
+import types
+import signe
+from .clientScope import _CLIENT_SCOPE_MANAGER
+from typing import (
+    Any,
+    Dict,
+    Protocol,
+    Type,
+    TypeVar,
+    Generic,
+    overload,
+    Optional,
+    Callable,
+    cast,
+    Union,
+)
+from .scheduler import get_uiScheduler
+from .types import (
+    ReadonlyRef,
+    DescReadonlyRef,
+)
+
+
+T = TypeVar("T", covariant=True)
+
+
+class TInstanceCall(Protocol[T]):
+    def __call__(_, self) -> T:  # type: ignore
+        ...
+
+
+@overload
+def ref_computed(
+    fn: Union[Callable[[], T], TInstanceCall[T]],
+    *,
+    desc="",
+    debug_trigger: Optional[Callable[..., None]] = None,
+    priority_level: int = 1,
+    debug_name: Optional[str] = None,
+) -> ReadonlyRef[T]:
+    """Takes a getter function and returns a readonly reactive ref object for the returned value from the getter. It can also take an object with get and set functions to create a writable ref object.
+
+    @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#ref_computed
+    @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#ref_computed
+
+
+    Args:
+        fn (Callable[[], T]): _description_
+        desc (str, optional): _description_. Defaults to "".
+        debug_trigger (Optional[Callable[..., None]], optional): _description_. Defaults to None.
+        priority_level (int, optional): _description_. Defaults to 1.
+        debug_name (Optional[str], optional): _description_. Defaults to None.
+
+    """
+    ...
+
+
+@overload
+def ref_computed(
+    fn=None,
+    *,
+    desc="",
+    debug_trigger: Optional[Callable[..., None]] = None,
+    priority_level: int = 1,
+    debug_name: Optional[str] = None,
+) -> Callable[[Callable[..., T]], ReadonlyRef[T]]:
+    ...
+
+
+def ref_computed(
+    fn: Optional[Union[Callable[[], T], TInstanceCall[T]]] = None,
+    *,
+    desc="",
+    debug_trigger: Optional[Callable[..., None]] = None,
+    priority_level: int = 1,
+    debug_name: Optional[str] = None,
+) -> Union[ReadonlyRef[T], Callable[[Callable[..., T]], ReadonlyRef[T]]]:
+    kws = {
+        "debug_trigger": debug_trigger,
+        "priority_level": priority_level,
+        "debug_name": debug_name,
+    }
+
+    if fn:
+        if _helpers.is_class_define_method(fn):
+            return cast(
+                ref_computed_method[T],
+                ref_computed_method(fn, computed_args=kws),  # type: ignore
+            )  # type: ignore
+
+        getter = signe.Computed(
+            cast(Callable[[], T], fn),
+            **kws,
+            scope=_CLIENT_SCOPE_MANAGER.get_current_scope(),
+            scheduler=get_uiScheduler(),
+        )
+        return cast(DescReadonlyRef[T], getter)
+
+    else:
+
+        def wrap(fn: Callable[[], T]):
+            return ref_computed(fn, **kws)
+
+        return wrap
+
+
+class ref_computed_method(Generic[T]):
+    __isabstractmethod__: bool
+
+    def __init__(self, fget: Callable[[Any], T], computed_args: Dict) -> None:
+        self._fget = fget
+        self._computed_args = computed_args
+
+    def __set_name__(self, owner, name):
+        _helpers.add_computed_to_instance(owner, name, self._fget, self._computed_args)
+
+
+class _helpers:
+    @staticmethod
+    def is_class_define_method(fn: Callable):
+        has_name = hasattr(fn, "__name__")
+        qualname_prefix = f".<locals>.{fn.__name__}" if has_name else ""
+
+        return (
+            hasattr(fn, "__qualname__")
+            and has_name
+            and "." in fn.__qualname__
+            and qualname_prefix != fn.__qualname__[-len(qualname_prefix) :]
+            and (isinstance(fn, types.FunctionType))
+        )
+
+    @staticmethod
+    def add_computed_to_instance(
+        cls_type: Type, attr_name: str, fn: Callable, computed_args: Dict
+    ):
+        """
+        Add an attribute to an instance of a class.
+        """
+        original_init = cls_type.__init__
+
+        def new_init(self, *args, **kwargs):
+            original_init(self, *args, **kwargs)
+            setattr(self, attr_name, ref_computed(partial(fn, self), **computed_args))
+
+        cls_type.__init__ = new_init
+        return cls_type

ex4nicegui/utils/refWrapper.py

@@ -0,0 +1,57 @@
+import signe
+from typing import (
+    TypeVar,
+    Generic,
+    Optional,
+    Callable,
+    cast,
+)
+import warnings
+from .types import (
+    TGetterOrReadonlyRef,
+)
+
+T = TypeVar("T")
+
+
+class RefWrapper(Generic[T]):
+    __slot__ = ("_getter_fn", "_setter_fn", "")
+
+    def __init__(
+        self,
+        getter_or_ref: TGetterOrReadonlyRef[T],
+        setter_or_ref: Optional[Callable[[T], None]] = None,
+    ):
+        if signe.is_signal(getter_or_ref):
+            self._getter_fn = lambda: getter_or_ref.value
+
+            def ref_setter(v):
+                getter_or_ref.value = v  # type: ignore
+
+            self._setter_fn = ref_setter
+        elif isinstance(getter_or_ref, Callable):
+            self._getter_fn = getter_or_ref
+            self._setter_fn = setter_or_ref or (lambda x: None)
+        else:
+            self._getter_fn = lambda: getter_or_ref
+            self._setter_fn = lambda x: None
+
+        self._is_readonly = False
+
+    @property
+    def value(self) -> T:
+        return cast(T, self._getter_fn())
+
+    @value.setter
+    def value(self, new_value: T):
+        if self._is_readonly:
+            warnings.warn("readonly ref cannot be assigned.")
+            return
+        return self._setter_fn(new_value)
+
+
+def to_ref_wrapper(
+    getter_or_ref: TGetterOrReadonlyRef[T],
+    setter_or_ref: Optional[Callable[[T], None]] = None,
+):
+    return RefWrapper(getter_or_ref, setter_or_ref)