instaui 0.1.0__py3-none-any.whl

instaui/vars/path_var.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from abc import abstractmethod
+from typing import List, Optional, Union, Self
+from instaui.vars.mixin_types.pathable import PathableMixin, CanPathPropMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+
+
+class PathVar(PathableMixin):
+    def __getitem__(self, item: Union[str, int, CanPathPropMixin]):
+        return PathTrackerBindable(self)[item]
+
+    def inverse(self):
+        return PathTrackerBindable(self).inverse()
+
+    def __add__(self, other: str):
+        return PathTrackerBindable(self) + other
+
+    def __radd__(self, other: str):
+        return other + PathTrackerBindable(self)
+
+
+class PathTracker:
+    def __init__(self, paths: Optional[List[Union[str, List[str]]]] = None):
+        self.paths = paths or []
+
+    def __getitem__(self, key) -> Self:
+        return self.__new_self__([*self.paths, key])
+
+    def __getattr__(self, key) -> Self:
+        return self.__new_self__([*self.paths, key])
+
+    def inverse(self) -> Self:
+        return self.__new_self__([*self.paths, ["!"]])
+
+    def __add__(self, other: str) -> Self:
+        return self.__new_self__([*self.paths, ["+", other]])
+
+    def __radd__(self, other: str) -> Self:
+        return self.__new_self__([*self.paths, ["~+", other]])
+
+    @abstractmethod
+    def __new_self__(self, paths: List[Union[str, List[str]]]) -> Self:
+        pass
+
+
+class PathTrackerBindable(
+    PathTracker,
+    CanInputMixin,
+    ObservableMixin,
+    CanOutputMixin,
+    ElementBindingMixin,
+    StrFormatBindingMixin,
+):
+    def __init__(self, source: PathableMixin):
+        super().__init__()
+        self.__source = source
+
+    def __new_self__(self, paths: List[Union[str, List[str]]]) -> PathTrackerBindable:
+        obj = PathTrackerBindable(self.__source)
+        obj.paths = paths
+        return obj
+
+    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_observable_config(self):
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        data = self.__source._to_pathable_binding_config()
+
+        if self.paths:
+            data["path"] = [
+                ["bind", path._to_path_prop_binding_config()]
+                if isinstance(path, CanPathPropMixin)
+                else path
+                for path in self.paths
+            ]
+
+        return data

instaui/vars/ref.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+from typing import (
+    Dict,
+    Generic,
+    Optional,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from instaui.common.jsonable import Jsonable
+from instaui.vars.path_var import PathVar
+
+from .mixin_types.var_type import VarMixin
+from .mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from .mixin_types.observable import ObservableMixin
+from .mixin_types.element_binding import ElementBindingMixin
+from .mixin_types.pathable import CanPathPropMixin
+from .mixin_types.str_format_binding import StrFormatBindingMixin
+from . import _utils
+
+
+_T_Value = TypeVar("_T_Value")
+
+
+class Ref(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    ObservableMixin,
+    CanInputMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin[_T_Value],
+    Generic[_T_Value],
+):
+    VAR_TYPE = "ref"
+
+    def __init__(self, value: Optional[_T_Value] = None) -> None:
+        self.value = value  # type: ignore
+
+        sid, id = _utils.register_var(self)
+        self._sid = sid
+        self._id = id
+        self._debounced = None
+
+    def debounced(self, secounds: float):
+        self._debounced = secounds
+        return self
+
+    def __to_binding_config(self):
+        return {
+            "type": self.VAR_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_observable_config(self):
+        return self.__to_binding_config()
+
+    def _to_input_config(self):
+        return self.__to_binding_config()
+
+    def _to_output_config(self):
+        return self.__to_binding_config()
+
+    def _to_element_binding_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
+        data["type"] = self.VAR_TYPE
+
+        if self._debounced is not None:
+            data["debounced"] = self._debounced
+
+        return data
+
+
+TRef = Ref
+
+
+@overload
+def ref(value: Ref[_T_Value]) -> Ref[_T_Value]: ...
+
+
+@overload
+def ref(value: Optional[_T_Value] = None) -> Ref[_T_Value]: ...
+
+
+def ref(value: Union[Ref[_T_Value], _T_Value, None] = None):
+    if isinstance(value, Ref):
+        return value
+    return Ref(value)

instaui/vars/slot_prop.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+from typing import (
+    Dict,
+)
+from instaui.common.jsonable import Jsonable
+
+from instaui.vars.path_var import PathVar
+
+from .mixin_types.py_binding import CanInputMixin
+from .mixin_types.element_binding import ElementBindingMixin
+from .mixin_types.pathable import CanPathPropMixin
+
+
+class BindingSlotPropItem(
+    Jsonable,
+    PathVar,
+    ElementBindingMixin,
+    CanInputMixin,
+    CanPathPropMixin,
+):
+    def __init__(self, slot_id: str, name: str) -> None:
+        super().__init__()
+        self.name = name
+        self._id = slot_id
+
+    def _to_element_binding_config(self):
+        return self._to_binding_config()
+
+    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_pathable_binding_config(self) -> Dict:
+        return self._to_binding_config()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["type"] = "sp"
+        data["id"] = self._id
+
+        return data
+
+    def _to_binding_config(self) -> Dict:
+        return self._to_json_dict()

instaui/vars/state.py

@@ -0,0 +1,82 @@
+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:
+    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,82 @@
+from __future__ import annotations
+from typing import Any, Dict, Mapping, Optional, Union
+
+from instaui.common.jsonable import Jsonable
+
+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
+from . import _utils
+
+
+class VueComputed(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    CanInputMixin,
+    ObservableMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    VAR_TYPE = "vComputed"
+    BIND_TYPE = "computed"
+
+    def __init__(
+        self,
+        fn_code: str,
+        bindings: Optional[Mapping[str, Union[ElementBindingMixin, Any]]] = None,
+    ) -> None:
+        self.code = fn_code
+
+        sid, id = _utils.register_var(self)
+        self._sid = sid
+        self._id = 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
+        data["type"] = self.VAR_TYPE
+        return data
+
+
+TVueComputed = VueComputed