ex4nicegui 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

ex4nicegui/reactive/officials/column.py

@@ -1,18 +1,33 @@
 from typing import (
     Any,
 )
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    _TMaybeRef as TMaybeRef,
+)
 from nicegui import ui
 from .base import BindableUi
 
 
 class ColumnBindableUi(BindableUi[ui.column]):
-    def __init__(
-        self,
-    ) -> None:
-        element = ui.column()
+    def __init__(self, *, wrap: TMaybeRef[bool] = True) -> None:
+        pc = ParameterClassifier(locals(), maybeRefs=["wrap"], events=[])
+        element = ui.column(**pc.get_values_kws())
 
         super().__init__(element)
 
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+        if prop == "wrap":
+            return self.bind_wrap(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_wrap(self, ref_ui: TMaybeRef):
+        self.bind_classes({"wrap": ref_ui})
+
     def __enter__(self):
         self.element.__enter__()
         return self

ex4nicegui/reactive/officials/html.py

@@ -5,7 +5,7 @@ from ex4nicegui.utils.signals import (
     to_value,
 )
 from nicegui import ui
-from .base import BindableUi, _bind_color
+from .base import BindableUi
 
 
 class HtmlComponent(ui.element, component="html.js"):

ex4nicegui/reactive/officials/knob.py

@@ -0,0 +1,75 @@
+from typing import (
+    Any,
+    Callable,
+    Optional,
+)
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.apiEffect import ui_effect
+
+from ex4nicegui.utils.signals import (
+    ReadonlyRef,
+    _TMaybeRef as TMaybeRef,
+    to_value,
+)
+from nicegui import ui
+from .base import BindableUi, DisableableMixin
+
+
+class KnobBindableUi(
+    BindableUi[ui.knob],
+    DisableableMixin,
+):
+    def __init__(
+        self,
+        value: TMaybeRef[float] = 0.0,
+        *,
+        min: TMaybeRef[float] = 0.0,  # pylint: disable=redefined-builtin
+        max: TMaybeRef[float] = 1.0,  # pylint: disable=redefined-builtin
+        step: TMaybeRef[float] = 0.01,
+        color: Optional[TMaybeRef[str]] = "primary",
+        center_color: Optional[TMaybeRef[str]] = None,
+        track_color: Optional[TMaybeRef[str]] = None,
+        size: Optional[TMaybeRef[str]] = None,
+        show_value: TMaybeRef[bool] = False,
+        on_change: Optional[Callable[..., Any]] = None,
+    ) -> None:
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=[
+                "value",
+                "min",
+                "max",
+                "step",
+                "color",
+                "center_color",
+                "track_color",
+                "size",
+                "show_value",
+            ],
+            v_model=("value", "on_change"),
+            events=["on_change"],
+        )
+
+        value_kws = pc.get_values_kws()
+        element = ui.knob(**value_kws)
+        super().__init__(element)  # type: ignore
+
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    @property
+    def value(self):
+        return self.element.value
+
+    def bind_prop(self, prop: str, ref_ui: ReadonlyRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_value(self, ref_ui: ReadonlyRef[float]):
+        @ui_effect
+        def _():
+            self.element.set_value(to_value(ref_ui))
+
+        return self

ex4nicegui/reactive/officials/label.py

@@ -1,6 +1,5 @@
 from typing import Any
 from ex4nicegui.reactive.utils import ParameterClassifier
-from ex4nicegui.utils.apiEffect import ui_effect
 from ex4nicegui.utils.signals import (
     to_value,
     _TMaybeRef as TMaybeRef,

ex4nicegui/reactive/officials/number.py

@@ -4,7 +4,6 @@ from typing import (
     Optional,
     TypeVar,
     Dict,
-    Union,
 )
 from ex4nicegui.reactive.utils import ParameterClassifier
 from ex4nicegui.utils.apiEffect import ui_effect
@@ -26,7 +25,7 @@ class NumberBindableUi(BindableUi[ui.number]):
         label: Optional[TMaybeRef[str]] = None,
         *,
         placeholder: Optional[TMaybeRef[str]] = None,
-        value: TMaybeRef[Union[float, None]] = None,
+        value: Optional[TMaybeRef[float]] = None,
         min: Optional[TMaybeRef[float]] = None,
         max: Optional[TMaybeRef[float]] = None,
         step: Optional[TMaybeRef[float]] = None,

ex4nicegui/reactive/officials/row.py

@@ -1,17 +1,31 @@
 from typing import (
     Any,
 )
+from ex4nicegui.reactive.utils import ParameterClassifier
+from ex4nicegui.utils.signals import (
+    _TMaybeRef as TMaybeRef,
+)
 from nicegui import ui
 from .base import BindableUi
 
 
 class RowBindableUi(BindableUi[ui.row]):
-    def __init__(
-        self,
-    ) -> None:
-        element = ui.row()
+    def __init__(self, *, wrap: TMaybeRef[bool] = True) -> None:
+        pc = ParameterClassifier(locals(), maybeRefs=["wrap"], events=[])
+        element = ui.row(**pc.get_values_kws())
 
         super().__init__(element)
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
+
+    def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+        if prop == "wrap":
+            return self.bind_wrap(ref_ui)
+
+        return super().bind_prop(prop, ref_ui)
+
+    def bind_wrap(self, ref_ui: TMaybeRef):
+        self.bind_classes({"wrap": ref_ui})
 
     def __enter__(self):
         self.element.__enter__()

ex4nicegui/reactive/q_pagination.py

@@ -1,45 +1,49 @@
-from typing import cast
-from nicegui.element import Element
+from typing import Any, Optional, Callable
+from ex4nicegui.reactive.utils import ParameterClassifier
 from ex4nicegui.utils.signals import (
-    Ref,
-    effect,
     to_value,
     _TMaybeRef as TMaybeRef,
 )
+from nicegui import ui
+from ex4nicegui.reactive.officials.base import BindableUi
 
 
-class QPagination(Element):
-    VALUE_PROP: str = "model-value"
-    LOOPBACK = False
-
+class PaginationBindableUi(BindableUi[ui.pagination]):
     def __init__(
         self,
-        value: TMaybeRef[int] = 1,
-        min: TMaybeRef[int] = 1,
-        max: TMaybeRef[int] = 5,
+        min: TMaybeRef[int],
+        max: TMaybeRef[int],
+        *,  # pylint: disable=redefined-builtin
+        direction_links: TMaybeRef[bool] = False,
+        value: TMaybeRef[int] = ...,  # type: ignore
+        on_change: Optional[Callable[..., Any]] = None,
     ) -> None:
-        super().__init__(tag="q-pagination")
+        pc = ParameterClassifier(
+            locals(),
+            maybeRefs=["min", "max", "direction_links", "value"],
+            v_model=("value", "on_change"),
+            events=["on_change"],
+        )
 
-        self.__value = value
-        self.__min = min
-        self.__max = max
+        element = ui.pagination(**pc.get_values_kws())
+        super().__init__(element)
 
-        def onchange(e):
-            arg_value = cast(int, e.args)
+        for key, value in pc.get_bindings().items():
+            self.bind_prop(key, value)  # type: ignore
 
-            self._props["model-value"] = arg_value
-            if isinstance(self.__value, Ref):
-                self.__value.value = arg_value
-            self.update()
+    @property
+    def value(self):
+        return self.element.value
 
-        self.on("update:model-value", onchange)
+    def bind_prop(self, prop: str, ref_ui: TMaybeRef):
+        if prop == "value":
+            return self.bind_value(ref_ui)
 
-        @effect
-        def _():
-            self._props["model-value"] = to_value(value)
-            self._props["min"] = to_value(min)
+        return super().bind_prop(prop, ref_ui)
 
-            if self.__max is not None:
-                self._props["max"] = to_value(self.__max)
+    def bind_value(self, ref_ui: TMaybeRef[int]):
+        @self._ui_effect
+        def _():
+            self.element.set_value(to_value(ref_ui))
 
-            self.update()
+        return self

ex4nicegui/reactive/usePagination.py

@@ -6,10 +6,10 @@ from ex4nicegui.utils.signals import (
     effect,
     _TMaybeRef as TMaybeRef,
 )
-from typing import Any, TypeVar
+from typing import Any
 from typing_extensions import Protocol
 import math
-from ex4nicegui.reactive.q_pagination import QPagination
+from ex4nicegui.reactive.q_pagination import PaginationBindableUi
 
 
 def _clamp(value, min_v, max_v) -> int:
@@ -97,6 +97,8 @@ class PaginationRef:
         return cp
 
     def create_q_pagination(self):
-        page = QPagination(self.current_page, max=self.page_count)
-        page.props("boundary-links direction-links")
+        page = PaginationBindableUi(
+            min=1, max=self.page_count, direction_links=True, value=self.current_page
+        )
+        page.props("boundary-links")
         return page

ex4nicegui/reactive/utils.py

@@ -1,9 +1,33 @@
-from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple, cast
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Protocol,
+    Tuple,
+    cast,
+    runtime_checkable,
+    Union,
+)
 
 from ex4nicegui.utils.signals import is_ref, to_value, is_setter_ref
 from nicegui.events import handle_event
 
 
+@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()}
 
@@ -24,7 +48,7 @@ class ParameterClassifier:
         if extend_kws:
             exclude.append(extend_kws)
 
-        self._args = {
+        self._args: Dict[str, Any] = {
             k: v
             for k, v in args.items()
             if k != "self" and k[0] != "_" and (k not in exclude)
@@ -70,7 +94,22 @@ class ParameterClassifier:
 
     def get_bindings(self) -> Dict:
         return {
-            k: v
+            k.replace("_", "-"): v
             for k, v in self._args.items()
             if (k in self.maybeRefs and (is_ref(v) or isinstance(v, Callable)))
         }
+
+
+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/vfor.py

@@ -2,13 +2,18 @@ from __future__ import annotations
 from nicegui.element import Element
 from nicegui import ui
 from ex4nicegui.utils.clientScope import _CLIENT_SCOPE_MANAGER
-from ex4nicegui.utils.signals import ReadonlyRef, on, to_ref, to_ref_wrapper
+from ex4nicegui.utils.signals import (
+    TReadonlyRef,
+    on,
+    to_ref,
+    to_ref_wrapper,
+    TGetterOrReadonlyRef,
+)
 from typing import (
     Any,
     Callable,
     Dict,
     List,
-    Mapping,
     Optional,
     TypeVar,
     Generic,
@@ -17,11 +22,11 @@ from typing import (
 )
 from functools import partial
 from dataclasses import dataclass
-from signe.core.reactive import DictProxy as signe_DictProxy
 from signe.core.scope import Scope
+from .utils import get_attribute
 
 _T = TypeVar("_T")
-_T_data = ReadonlyRef[List[Any]]
+_T_data = TGetterOrReadonlyRef[List[Any]]
 
 
 class VforStore(Generic[_T]):
@@ -33,29 +38,17 @@ class VforStore(Generic[_T]):
     def row_index(self):
         return self._data_index
 
-    def get(self, attr: Optional[str] = None) -> _T:
-        item = self._source.value[self._data_index.value]
-
-        if attr:
-            setter = None
-            if isinstance(item, signe_DictProxy):
-
-                def base_setter(value):
-                    item[attr] = value
+    def get(self) -> TReadonlyRef[_T]:
+        def base_setter(value):
+            self._source.value[self._data_index.value] = value
 
-                setter = base_setter
-            else:
-                setter = lambda x: _set_attribute(item, attr, x)  # noqa: E731
-
-            return cast(
-                _T,
-                to_ref_wrapper(
-                    lambda: _get_attribute(item, attr),
-                    setter,
-                ),
-            )
+        wrapper = to_ref_wrapper(
+            lambda: self._source.value[self._data_index.value],
+            base_setter,
+        )
+        wrapper._is_readonly = True
 
-        return item
+        return cast(TReadonlyRef, wrapper)
 
     def update(self, index: int):
         self._data_index.value = index
@@ -73,25 +66,12 @@ class VforContainer(Element, component="vfor.js"):
     pass
 
 
-def _get_attribute(obj: Union[object, Mapping], name: str) -> Any:
-    if isinstance(obj, Mapping):
-        return obj[name]
-    return getattr(obj, name)
-
-
-def _set_attribute(obj: Union[object, Mapping], name: str, value: Any) -> None:
-    if isinstance(obj, dict):
-        obj[name] = value
-    else:
-        setattr(obj, name, value)
-
-
 def _get_key_with_index(idx: int, data: Any):
     return idx
 
 
 def _get_key_with_getter(attr: str, idx: int, data: Any):
-    return _get_attribute(data, attr)
+    return get_attribute(data, attr)
 
 
 class vfor(Generic[_T]):

ex4nicegui/reactive/vmodel.py

@@ -0,0 +1,210 @@
+from __future__ import annotations
+import inspect
+from io import BytesIO
+from ex4nicegui.utils.signals import (
+    RefWrapper,
+    TRef,
+    to_raw,
+    is_setter_ref,
+    to_ref_wrapper,
+    to_value,
+    is_reactive,
+    is_setter_ref,
+    to_ref_wrapper,
+    to_value,
+)
+from typing import (
+    Any,
+    Callable,
+    TypeVar,
+    Union,
+    cast,
+    Tuple,
+    NamedTuple,
+)
+
+from types import FrameType
+import tokenize
+import executing
+import ast
+import warnings
+from .utils import get_attribute, set_attribute
+
+_T = TypeVar("_T")
+
+
+def get_caller() -> FrameType:
+    return inspect.currentframe().f_back.f_back  # type: ignore
+
+
+def get_args_code(caller: FrameType) -> str:
+    node = executing.Source.executing(caller).node
+
+    assert isinstance(node, ast.Call)
+
+    source = inspect.getsource(inspect.getmodule(caller))  # type: ignore
+    key_code = ast.get_source_segment(source, node.args[0])
+    return key_code  # type: ignore
+
+
+class CodeInfo(NamedTuple):
+    model: str
+    is_ref: bool
+    keys: Tuple[Union[str, int], ...] = tuple()  # type: ignore
+
+
+def normalize(token: tokenize.TokenInfo):
+    if token.type == tokenize.NUMBER:
+        return int(token.string)
+
+    if token.type == tokenize.STRING:
+        return token.string[1:-1]
+
+    return token.string
+
+
+def parse_code(code: str) -> CodeInfo:
+    tokens = [
+        t
+        for t in tokenize.tokenize(BytesIO(code.encode("utf8")).readline)
+        if t.type in (tokenize.NAME, tokenize.NUMBER, tokenize.OP, tokenize.STRING)
+    ]
+
+    model = tokens[0].string
+    is_ref = (
+        len(tokens) >= 3
+        and tokens[1].type == tokenize.OP
+        and tokens[1].string == "."
+        and tokens[2].string == "value"
+    )
+
+    keys_search_start = 3 if is_ref else 1
+
+    keys = tuple(
+        normalize(token)
+        for token in tokens[keys_search_start:]
+        if token.type != tokenize.OP
+    )
+
+    return CodeInfo(model, is_ref, keys)
+
+
+def create_writeable_wrapper(expr, ref_data, attrs: Tuple[Union[str, int], ...]):
+    if not attrs:
+
+        def maybe_ref_getter():
+            return to_value(expr)
+
+        def reactive_getter():
+            return to_raw(expr)
+
+        def setter(value):
+            pass
+
+        wrapper = to_ref_wrapper(
+            reactive_getter if is_reactive(expr) else maybe_ref_getter,
+            setter,
+        )
+        wrapper._is_readonly = False
+        return wrapper
+
+    def getter():
+        obj = get_attribute(to_value(ref_data), attrs[0])
+        for attr in attrs[1:]:
+            obj = get_attribute(obj, attr)
+
+        return obj
+
+    def setter(value):
+        obj = to_value(ref_data)
+
+        for attr in attrs[:-1]:
+            obj = get_attribute(obj, attr)
+
+        set_attribute(obj, attrs[-1], value)
+
+    wrapper = to_ref_wrapper(
+        getter,
+        setter,
+    )
+    wrapper._is_readonly = False
+    return wrapper
+
+
+def vmodel(expr: Any, *attrs: Union[str, int]) -> TRef[Any]:
+    """Create a two-way binding on a form input element or a component.
+
+    @see - https://github.com/CrystalWindSnake/ex4nicegui/blob/main/README.en.md#vmodel
+    @中文文档 - https://gitee.com/carson_add/ex4nicegui/tree/main/#vmodel
+
+    Args:
+        expr (Any): _description_
+
+    ## Examples
+    ```python
+    from ex4nicegui.reactive import rxui
+    from ex4nicegui import deep_ref
+
+    data = deep_ref({"a": 1, "b": [1, 2, 3, 4]})
+
+    rxui.label(lambda: f"{data.value=!s}")
+
+    # No binding effect
+    rxui.input(value=data.value["a"])
+
+    # readonly binding
+    rxui.input(value=lambda: data.value["a"])
+
+    # two-way binding
+    rxui.input(value=rxui.vmodel(data.value["a"]))
+    ```
+
+    """
+
+    assert not isinstance(expr, Callable), "argument expr cannot be a function"
+
+    if isinstance(expr, RefWrapper):
+        expr._is_readonly = False
+
+    if is_setter_ref(expr):
+        if attrs:
+            wrapper = create_writeable_wrapper(expr, expr, attrs)
+
+            return cast(
+                TRef,
+                wrapper,
+            )
+
+        return cast(
+            TRef,
+            expr,
+        )
+
+    caller = get_caller()
+    code = get_args_code(caller)
+
+    info = parse_code(code)
+    ref_data = caller.f_locals.get(info.model) or caller.f_globals.get(info.model)
+    assert ref_data is not None, f"{info.model} not found"
+    all_attrs = (*info.keys, *attrs)
+
+    if not all_attrs:
+        warn_mes = ""
+        if is_reactive(expr) or is_setter_ref(expr):
+            warn_mes = rf"""Expression missing the key,result is read-only binding.Maybe you meant `{code}['key']`"""
+        elif not info.is_ref:
+            warn_mes = """Maybe you don't need to use vmodel"""
+        else:
+            warn_mes = rf"""No binding.Maybe you meant `{info.model}`"""
+
+        warnings.warn(
+            warn_mes,
+            stacklevel=2,
+        )
+
+    wrapper = create_writeable_wrapper(expr, ref_data, all_attrs)
+
+    return cast(
+        TRef,
+        wrapper,
+    )

ex4nicegui/tools/__init__.py

@@ -1 +0,0 @@
-from .debug import display_ref_vars_ui

ex4nicegui/tools/debug.py

@@ -2,7 +2,7 @@ from signe.core.effect import Effect
 import ex4nicegui.reactive as rxui
 from ex4nicegui.utils.signals import ReadonlyRef, DescReadonlyRef, Ref, ref_computed
 from nicegui import ui
-from typing import Callable, Dict, TypeVar, Generic
+from typing import Dict, TypeVar
 
 T = TypeVar("T")