instaui 0.1.15__py2.py3-none-any.whl

instaui/vars/state.py

@@ -0,0 +1,97 @@
+from typing import Dict, Tuple, TypeVar
+
+from instaui import ui
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.common.jsonable import Jsonable
+
+from pydantic import BaseModel, RootModel
+
+_T = TypeVar("_T")
+
+
+_ProxyModel = RootModel
+
+
+class RefProxy(
+    CanInputMixin,
+    ObservableMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+    Jsonable,
+):
+    def __init__(self, instance: BaseModel) -> None:
+        data = instance.model_dump()
+        self._ref_ = ui.ref(data)
+        self._prop_names_ = set(data.keys()) if isinstance(data, dict) else set()
+
+    def __getattribute__(self, name):
+        if name not in super().__getattribute__("_prop_names_"):
+            return super().__getattribute__(name)
+
+        return super().__getattribute__("_ref_")[name]
+
+    def __getitem__(self, name):
+        return super().__getattribute__("_ref_")[name]
+
+    def inverse(self):
+        return super().__getattribute__("_ref_").inverse()
+
+    def __add__(self, other: str):
+        return super().__getattribute__("_ref_") + other
+
+    def __radd__(self, other: str):
+        return other + super().__getattribute__("_ref_")
+
+    def _to_element_binding_config(self) -> Dict:
+        return super().__getattribute__("_ref_")._to_element_binding_config()
+
+    def _to_input_config(self):
+        return super().__getattribute__("_ref_")._to_input_config()
+
+    def _to_observable_config(self):
+        return super().__getattribute__("_ref_")._to_observable_config()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return super().__getattribute__("_ref_")._to_path_prop_binding_config()
+
+    def _to_output_config(self):
+        return super().__getattribute__("_ref_")._to_output_config()
+
+    def _to_str_format_binding(self, order: int) -> Tuple[str, str]:
+        return super().__getattribute__("_ref_")._to_str_format_binding(order)
+
+    def _to_json_dict(self):
+        return super().__getattribute__("_ref_")._to_json_dict()
+
+
+class StateModel(BaseModel, Jsonable):
+    pass
+
+    def _to_json_dict(self):
+        return self.model_dump()
+
+
+def state(value: _T) -> _T:
+    """
+    Creates a reactive state object that tracks changes and notifies dependencies.
+
+    Args:
+        value (_T): The initial value to wrap in a reactive state container.
+                   Can be any type (primitive, object, or complex data structure).
+
+    # Example:
+    .. code-block:: python
+        from instaui import ui,html
+        count = ui.state(0)
+
+        html.number(count)
+        ui.label(count)
+    """
+    obj = RefProxy(_ProxyModel(value))  # type: ignore
+    return obj  # type: ignore

instaui/vars/types.py

@@ -0,0 +1,24 @@
+from typing import Any, Union
+from .ref import Ref
+from .js_computed import JsComputed
+from .vue_computed import VueComputed
+from .web_computed import WebComputed
+
+
+from ._types import _T_Value
+from .mixin_types.element_binding import ElementBindingMixin
+
+
+TRefOrComputed = Union[
+    Ref[_T_Value],
+    VueComputed,
+    JsComputed,
+    WebComputed[Any, _T_Value],
+]
+TMaybeRef = Union[
+    ElementBindingMixin[_T_Value],
+    WebComputed,
+    VueComputed,
+    JsComputed,
+    _T_Value,
+]

instaui/vars/vfor_item.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+from typing import Dict, Generic, Tuple, TypeVar, TYPE_CHECKING, Union, cast
+from contextlib import contextmanager
+
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.path_var import PathVar
+
+if TYPE_CHECKING:
+    from instaui.components.vfor import VFor
+
+_T = TypeVar("_T")
+
+
+class VForItemProxy(
+    PathVar,
+    CanInputMixin,
+    ObservableMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+    Jsonable,
+    Generic[_T],
+):
+    def __init__(self, vfor_item: VForItem[_T]):
+        self._vfor_item = vfor_item
+
+    def __getattr__(self, name: str):
+        return self._vfor_item[name]
+
+    def __getitem__(self, name):
+        return super().__getattribute__("_vfor_item")[name]
+
+    def _to_element_binding_config(self) -> Dict:
+        return super().__getattribute__("_vfor_item")._to_element_binding_config()
+
+    def _to_input_config(self):
+        return super().__getattribute__("_vfor_item")._to_input_config()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return super().__getattribute__("_vfor_item")._to_path_prop_binding_config()
+
+    def _to_output_config(self):
+        return super().__getattribute__("_vfor_item")._to_output_config()
+
+    def _to_str_format_binding(self, order: int) -> Tuple[str, str]:
+        return super().__getattribute__("_vfor_item")._to_str_format_binding(order)
+
+    def _to_pathable_binding_config(self) -> Dict:
+        return super().__getattribute__("_vfor_item")._to_pathable_binding_config()
+
+    def _to_observable_config(self):
+        return super().__getattribute__("_vfor_item")._to_observable_config()
+
+    def _to_json_dict(self):
+        return super().__getattribute__("_vfor_item")._to_json_dict()
+
+
+class VForItem(
+    PathVar,
+    CanInputMixin,
+    ObservableMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    ElementBindingMixin[_T],
+    StrFormatBindingMixin,
+    Generic[_T],
+):
+    VAR_Type = "vf"
+
+    def __init__(self, vfor: VFor):
+        super().__init__()
+        self._vfor = vfor
+
+    @property
+    def dict_key(self):
+        return self._vfor.current[1]
+
+    @property
+    def dict_value(self):
+        return self._vfor.current[0]
+
+    @property
+    def proxy(self):
+        return cast(_T, VForItemProxy(self))
+
+    def _to_binding_config(self) -> Union[Jsonable, Dict]:
+        return self._to_json_dict()
+
+    def _to_element_binding_config(self):
+        return self._to_json_dict()
+
+    def _to_input_config(self):
+        return self._to_json_dict()
+
+    def _to_output_config(self):
+        return self._to_json_dict()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return self._to_json_dict()
+
+    def _to_pathable_binding_config(self) -> Dict:
+        return self._to_json_dict()
+
+    def _to_observable_config(self):
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        data: Dict = {
+            "type": self.VAR_Type,
+            "fid": self._vfor._fid,
+        }
+
+        return data
+
+
+class VForIndex(
+    CanInputMixin,
+    CanPathPropMixin,
+    ElementBindingMixin,
+    StrFormatBindingMixin,
+):
+    def __init__(self, vfor: VFor):
+        super().__init__()
+        self._vfor = vfor
+
+    def _to_element_binding_config(self):
+        return self._to_json_dict()
+
+    def _to_input_config(self):
+        return self._to_json_dict()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        return {
+            "type": "vf-i",
+            "fid": self._vfor._fid,
+        }
+
+
+class VForDict(
+    CanInputMixin,
+    CanOutputMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+    Jsonable,
+):
+    def __init__(self, vfor: VFor):
+        self._vfor = vfor
+
+    @property
+    def dict_key(self):
+        return self._vfor.current[1]
+
+    @property
+    def dict_value(self):
+        return self._vfor.current[0]
+
+    @contextmanager
+    def with_index(self):
+        self.__enter__()
+        yield self, cast(int, VForIndex(self._vfor))
+
+    def __enter__(self):
+        self._vfor.__enter__()
+        return self
+
+    def __exit__(self, *_) -> None:
+        return self._vfor.__exit__(*_)
+
+    def _to_element_binding_config(self) -> Dict:
+        return self.dict_value._to_element_binding_config()
+
+    def _to_input_config(self):
+        return self.dict_value._to_input_config()
+
+    def _to_output_config(self):
+        return self.dict_value._to_output_config()
+
+    def _to_json_dict(self):
+        return self.dict_value._to_json_dict()
+
+
+class VForWithIndex(Generic[_T]):
+    def __init__(self, vfor: VFor[_T]):
+        self._vfor = vfor
+
+    def __enter__(self):
+        self._vfor.__enter__()
+        return cast(_T, self._vfor.current.proxy), cast(int, VForIndex(self._vfor))
+
+    def __exit__(self, *_) -> None:
+        return self._vfor.__exit__(*_)
+
+
+TVForItem = VForItem
+TVForIndex = VForIndex

instaui/vars/vue_computed.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+from typing import Any, Dict, Mapping, Optional, Union
+
+from instaui.common.jsonable import Jsonable
+
+from instaui.runtime._app import get_current_scope
+from instaui.vars.path_var import PathVar
+from instaui.vars.mixin_types.var_type import VarMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.py_binding import CanInputMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+
+
+class VueComputed(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    CanInputMixin,
+    ObservableMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    BIND_TYPE = "var"
+
+    def __init__(
+        self,
+        fn_code: str,
+        bindings: Optional[Mapping[str, Union[ElementBindingMixin, Any]]] = None,
+    ) -> None:
+        self.code = fn_code
+        scope = get_current_scope()
+        scope.register_vue_computed(self)
+
+        self._sid = scope.id
+        self._id = scope.generate_vars_id()
+
+        if bindings:
+            const_bind = []
+            self.bind = {}
+
+            for k, v in bindings.items():
+                is_binding = isinstance(v, ElementBindingMixin)
+                self.bind[k] = v._to_element_binding_config() if is_binding else v
+                const_bind.append(int(not is_binding))
+
+            if any(i == 1 for i in const_bind):
+                self.const = const_bind
+
+    def __to_binding_config(self):
+        return {
+            "type": self.BIND_TYPE,
+            "id": self._id,
+            "sid": self._sid,
+        }
+
+    def _to_input_config(self):
+        return self.__to_binding_config()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return self.__to_binding_config()
+
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
+
+    def _to_pathable_binding_config(self) -> Dict:
+        return self.__to_binding_config()
+
+    def _to_observable_config(self):
+        return self.__to_binding_config()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["sid"] = self._sid
+        data["id"] = self._id
+        return data
+
+
+TVueComputed = VueComputed

instaui/vars/web_computed.py

@@ -0,0 +1,209 @@
+from __future__ import annotations
+import inspect
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Optional,
+    Sequence,
+    TypeVar,
+)
+from typing_extensions import ParamSpec
+
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_app_slot, get_current_scope
+from instaui.handlers import watch_handler
+
+from instaui.vars.path_var import PathVar
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.common_type import TObservableInput
+from instaui._helper import observable_helper
+
+_SYNC_TYPE = "sync"
+_ASYNC_TYPE = "async"
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class WebComputed(
+    Jsonable,
+    PathVar,
+    CanInputMixin,
+    ObservableMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin[R],
+    Generic[P, R],
+):
+    BIND_TYPE = "var"
+
+    def __init__(
+        self,
+        func: Callable[P, R],
+        inputs: Optional[Sequence[TObservableInput]] = None,
+        extend_outputs: Optional[Sequence[CanOutputMixin]] = None,
+        init_value: Optional[R] = None,
+        evaluating: Optional[CanOutputMixin] = None,
+        deep_compare_on_input: bool = False,
+        debug_info: Optional[Dict] = None,
+    ) -> None:
+        scope = get_current_scope()
+
+        self._sid = scope.id
+        self._id = scope.generate_vars_id()
+        get_current_scope().register_web_computed(self)
+
+        self._org_inputs = inputs or []
+
+        self._inputs, self._is_slient_inputs, self._is_data = (
+            observable_helper.analyze_observable_inputs(list(inputs or []))
+        )
+        self._outputs = [output._to_output_config() for output in extend_outputs or []]
+        self._fn = func
+        self._init_value = init_value
+        self._evaluating = evaluating
+        self._deep_compare_on_input = deep_compare_on_input
+        self.__be_used = False
+
+        if debug_info is not None:
+            self.debug = debug_info
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        return self._fn(*args, **kwargs)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        app = get_app_slot()
+
+        hkey = watch_handler.create_handler_key(
+            page_path=app.page_path,
+            handler=self._fn,
+        )
+
+        watch_handler.register_handler(hkey, self._fn, len(self._outputs) + 1)
+
+        data["id"] = self._id
+        data["sid"] = self._sid
+
+        if self._inputs:
+            data["inputs"] = self._inputs
+
+        if self._outputs:
+            data["outputs"] = self._outputs
+
+        if sum(self._is_slient_inputs) > 0:
+            data["slient"] = self._is_slient_inputs
+
+        if sum(self._is_data) > 0:
+            data["data"] = self._is_data
+
+        data["fType"] = (
+            _ASYNC_TYPE if inspect.iscoroutinefunction(self._fn) else _SYNC_TYPE
+        )
+        data["key"] = hkey
+        if self._init_value is not None:
+            data["init"] = self._init_value
+
+        if self._evaluating:
+            data["running"] = self._evaluating._to_output_config()
+
+        if self._deep_compare_on_input is not False:
+            data["deepEqOnInput"] = 1
+
+        return data
+
+    def __to_binding_config(self):
+        return {
+            "type": self.BIND_TYPE,
+            "id": self._id,
+            "sid": self._sid,
+        }
+
+    def _to_pathable_binding_config(self) -> Dict:
+        return self.__to_binding_config()
+
+    def _to_path_prop_binding_config(self) -> Dict:
+        return self.__to_binding_config()
+
+    def _to_input_config(self):
+        return self.__to_binding_config()
+
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
+
+    def _to_observable_config(self):
+        return self.__to_binding_config()
+
+    def _mark_used(self):
+        if self.__be_used:
+            return
+
+        self.__be_used = True
+        for input_ in self._org_inputs:
+            if isinstance(input_, ElementBindingMixin):
+                input_._mark_used()
+
+    def _is_used(self):
+        return self.__be_used
+
+
+def web_computed(
+    *,
+    inputs: Optional[Sequence] = None,
+    extend_outputs: Optional[Sequence] = None,
+    init_value: Optional[Any] = None,
+    evaluating: Optional[Any] = None,
+    deep_compare_on_input: bool = False,
+    debug_info: Optional[Dict] = None,
+):
+    """
+    Creates a computed property decorator for reactive programming with dependency tracking.
+
+    This decorator factory wraps functions to create reactive computed properties that:
+    - Automatically re-evaluate when dependencies (inputs) change
+    - Cache results for performance optimization
+    - Support both synchronous and asynchronous computation patterns
+
+    Args:
+        inputs (Optional[Sequence], optional): Collection of reactive sources that trigger recomputation
+                                   when changed. These can be state objects or other computed properties.
+        extend_outputs (Optional[Sequence], optional):  Additional outputs to notify when this computed value updates.
+        init_value (Optional[Any], optional): Initial value to return before first successful evaluation.
+        evaluating (Optional[Any], optional): Temporary value returned during asynchronous computation.
+
+    # Example:
+    .. code-block:: python
+        from instaui import ui,html
+
+        a = ui.state(0)
+
+        @ui.computed(inputs=[a])
+        def plus_one(a):
+            return a + 1
+
+        html.number(a)
+        ui.label(plus_one)
+    """
+
+    def wrapper(func: Callable[P, R]):
+        return WebComputed(
+            func,
+            inputs=inputs,
+            extend_outputs=extend_outputs,
+            init_value=init_value,
+            evaluating=evaluating,
+            deep_compare_on_input=deep_compare_on_input,
+            debug_info=debug_info,
+        )
+
+    return wrapper
+
+
+TComputed = WebComputed

instaui/vars/web_view_computed.py

@@ -0,0 +1 @@
+from __future__ import annotations

instaui/version.py

@@ -0,0 +1,3 @@
+import importlib.metadata
+
+__version__: str = importlib.metadata.version("instaui")

instaui/watch/_types.py

@@ -0,0 +1,4 @@
+from typing import Literal
+
+
+TFlush = Literal["pre", "post", "sync"]

instaui/watch/_utils.py

@@ -0,0 +1,3 @@
+def assert_deep(deep):
+    if isinstance(deep, int):
+        assert deep >= 0, "deep must be greater than or equal to 0"