instaui 0.2.1__py2.py3-none-any.whl → 0.3.0__py2.py3-none-any.whl

instaui/vars/vfor_item.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
-from typing import Dict, Generic, Tuple, TypeVar, TYPE_CHECKING, Union, cast
-from contextlib import contextmanager
+from typing import Any, Dict, Generic, Tuple, TypeVar, Union, cast
 
 from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_current_scope
+from instaui.vars._types import InputBindingType, OutputSetType
 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
@@ -10,8 +11,6 @@ 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")
 
@@ -33,32 +32,42 @@ class VForItemProxy(
     def __getattr__(self, name: str):
         return self._vfor_item[name]
 
+    @property
+    def __vfor_item_(self):
+        return super().__getattribute__("_vfor_item")
+
     def __getitem__(self, name):
-        return super().__getattribute__("_vfor_item")[name]
+        return self.__vfor_item_[name]
 
     def _to_element_binding_config(self) -> Dict:
-        return super().__getattribute__("_vfor_item")._to_element_binding_config()
+        return self.__vfor_item_._to_element_binding_config()
 
     def _to_input_config(self):
-        return super().__getattribute__("_vfor_item")._to_input_config()
+        return self.__vfor_item_._to_input_config()
 
     def _to_path_prop_binding_config(self) -> Dict:
-        return super().__getattribute__("_vfor_item")._to_path_prop_binding_config()
+        return self.__vfor_item_._to_path_prop_binding_config()
 
     def _to_output_config(self):
-        return super().__getattribute__("_vfor_item")._to_output_config()
+        return self.__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)
+        return self.__vfor_item_._to_str_format_binding(order)
 
     def _to_pathable_binding_config(self) -> Dict:
-        return super().__getattribute__("_vfor_item")._to_pathable_binding_config()
+        return self.__vfor_item_._to_pathable_binding_config()
 
     def _to_observable_config(self):
-        return super().__getattribute__("_vfor_item")._to_observable_config()
+        return self.__vfor_item_._to_observable_config()
 
     def _to_json_dict(self):
-        return super().__getattribute__("_vfor_item")._to_json_dict()
+        return self.__vfor_item_._to_json_dict()
+
+    def _to_event_output_type(self) -> OutputSetType:
+        return self.__vfor_item_._to_event_output_type()
+
+    def _to_event_input_type(self) -> InputBindingType:
+        return self.__vfor_item_._to_event_input_type()
 
 
 class VForItem(
@@ -69,135 +78,224 @@ class VForItem(
     CanPathPropMixin,
     ElementBindingMixin[_T],
     StrFormatBindingMixin,
+    Jsonable,
     Generic[_T],
 ):
-    VAR_Type = "vf"
+    SCOPE_TYPE = "fv"
 
-    def __init__(self, vfor: VFor):
+    def __init__(self):
         super().__init__()
-        self._vfor = vfor
+        scope = get_current_scope()
+        self.__register_info = scope.register_vfor_item_task(self)
+
+    def __getattr__(self, name: str):
+        return self[name]
+
+    # def __getitem__(self, name):
+    #     return self[name]
 
     @property
     def dict_key(self):
-        return self._vfor.current[1]
+        return cast(Any, VForItemKey())
 
     @property
     def dict_value(self):
-        return self._vfor.current[0]
+        return self
+
+    @property
+    def index(self) -> int:
+        return cast(int, VForIndex())
 
     @property
-    def proxy(self):
-        return cast(_T, VForItemProxy(self))
+    def value(self) -> _T:
+        return cast(_T, self)
+
+    # @property
+    # def proxy(self):
+    #     return cast(_T, VForItemProxy(self))
 
     def _to_binding_config(self) -> Union[Jsonable, Dict]:
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_element_binding_config(self):
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_input_config(self):
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_output_config(self):
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_path_prop_binding_config(self) -> Dict:
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_pathable_binding_config(self) -> Dict:
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_observable_config(self):
-        return self._to_json_dict()
+        return self.__to_binding_config()
+
+    def __to_binding_config(self):
+        data: Dict = {
+            "sid": self.__register_info.scope_id,
+            "id": self.__register_info.var_id,
+        }
+
+        return data
 
     def _to_json_dict(self):
         data: Dict = {
-            "type": self.VAR_Type,
-            "fid": self._vfor._fid,
+            "id": self.__register_info.var_id,
         }
 
         return data
 
+    def _to_event_output_type(self) -> OutputSetType:
+        return OutputSetType.Ref
+
+    def _to_event_input_type(self) -> InputBindingType:
+        return InputBindingType.Ref
+
 
 class VForIndex(
     CanInputMixin,
     CanPathPropMixin,
     ElementBindingMixin,
     StrFormatBindingMixin,
+    Jsonable,
 ):
-    def __init__(self, vfor: VFor):
+    SCOPE_TYPE = "fi"
+
+    def __init__(self):
         super().__init__()
-        self._vfor = vfor
+        scope = get_current_scope()
+        self.__register_info = scope.register_vfor_index_task(self)
+
+    def __to_binding_config(self):
+        data: Dict = {
+            "sid": self.__register_info.scope_id,
+            "id": self.__register_info.var_id,
+        }
+
+        return data
 
     def _to_element_binding_config(self):
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_input_config(self):
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_path_prop_binding_config(self) -> Dict:
-        return self._to_json_dict()
+        return self.__to_binding_config()
 
     def _to_json_dict(self):
         return {
-            "type": "vf-i",
-            "fid": self._vfor._fid,
+            "id": self.__register_info.var_id,
         }
 
+    def _to_event_input_type(self) -> InputBindingType:
+        return InputBindingType.Ref
 
-class VForDict(
+
+class VForItemKey(
     CanInputMixin,
-    CanOutputMixin,
-    StrFormatBindingMixin,
+    CanPathPropMixin,
     ElementBindingMixin,
+    StrFormatBindingMixin,
     Jsonable,
 ):
-    def __init__(self, vfor: VFor):
-        self._vfor = vfor
+    SCOPE_TYPE = "fk"
 
-    @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 __init__(self):
+        super().__init__()
+        scope = get_current_scope()
+        self.__register_info = scope.register_vfor_key_task(self)
 
-    def __enter__(self):
-        self._vfor.__enter__()
-        return self
+    def __to_binding_config(self):
+        data: Dict = {
+            "sid": self.__register_info.scope_id,
+            "id": self.__register_info.var_id,
+        }
 
-    def __exit__(self, *_) -> None:
-        return self._vfor.__exit__(*_)
+        return data
 
-    def _to_element_binding_config(self) -> Dict:
-        return self.dict_value._to_element_binding_config()
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
 
     def _to_input_config(self):
-        return self.dict_value._to_input_config()
+        return self.__to_binding_config()
 
-    def _to_output_config(self):
-        return self.dict_value._to_output_config()
+    def _to_path_prop_binding_config(self) -> Dict:
+        return self.__to_binding_config()
 
     def _to_json_dict(self):
-        return self.dict_value._to_json_dict()
+        return {
+            "id": self.__register_info.var_id,
+        }
+
+    def _to_event_input_type(self) -> InputBindingType:
+        return InputBindingType.Ref
+
+
+# class VForDict(
+#     CanInputMixin,
+#     CanOutputMixin,
+#     StrFormatBindingMixin,
+#     ElementBindingMixin,
+#     Jsonable,
+# ):
+#     def __init__(self, vfor: VFor):
+#         self._vfor = vfor
+
+#     @property
+#     def dict_key(self):
+#         return self._vfor.current[0]
+
+#     @property
+#     def dict_value(self):
+#         return self._vfor.current[1]
+
+#     @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()
+
+#     def _to_event_output_type(self) -> EventOutputType:
+#         raise ValueError("VForDict does not support output events")
+
+#     def _to_event_input_type(self) -> EventInputType:
+#         return EventInputType.Ref
 
 
-class VForWithIndex(Generic[_T]):
-    def __init__(self, vfor: VFor[_T]):
-        self._vfor = vfor
+# 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 __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__(*_)
+#     def __exit__(self, *_) -> None:
+#         return self._vfor.__exit__(*_)
 
 
 TVForItem = VForItem

instaui/vars/vue_computed.py

@@ -4,6 +4,7 @@ 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._types import InputBindingType
 from instaui.vars.path_var import PathVar
 from instaui.vars.mixin_types.var_type import VarMixin
 from instaui.vars.mixin_types.element_binding import (
@@ -26,8 +27,6 @@ class VueComputed(
     StrFormatBindingMixin,
     ElementBindingMixin,
 ):
-    BIND_TYPE = "var"
-
     def __init__(
         self,
         fn_code: str,
@@ -55,7 +54,6 @@ class VueComputed(
 
     def __to_binding_config(self):
         return {
-            "type": self.BIND_TYPE,
             "id": self.__register_info.var_id,
             "sid": self.__register_info.scope_id,
         }
@@ -77,9 +75,11 @@ class VueComputed(
 
     def _to_json_dict(self):
         data = super()._to_json_dict()
-        data["sid"] = self.__register_info.scope_id
         data["id"] = self.__register_info.var_id
         return data
 
+    def _to_event_input_type(self) -> InputBindingType:
+        return InputBindingType.Ref
+
 
 TVueComputed = VueComputed

instaui/vars/web_computed.py

@@ -15,8 +15,13 @@ 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._types import InputBindingType
 from instaui.vars.path_var import PathVar
-from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.py_binding import (
+    CanInputMixin,
+    CanOutputMixin,
+    outputs_to_config,
+)
 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
@@ -41,8 +46,6 @@ class WebComputed(
     ElementBindingMixin[R],
     Generic[P, R],
 ):
-    BIND_TYPE = "var"
-
     def __init__(
         self,
         func: Callable[P, R],
@@ -61,7 +64,7 @@ class WebComputed(
         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._outputs = outputs_to_config([output for output in extend_outputs or []])
         self._fn = func
         self._init_value = init_value
         self._evaluating = evaluating
@@ -86,7 +89,6 @@ class WebComputed(
         watch_handler.register_handler(hkey, self._fn, len(self._outputs) + 1)
 
         data["id"] = self.__register_info.var_id
-        data["sid"] = self.__register_info.scope_id
 
         if self._inputs:
             data["inputs"] = self._inputs
@@ -117,7 +119,6 @@ class WebComputed(
 
     def __to_binding_config(self):
         return {
-            "type": self.BIND_TYPE,
             "id": self.__register_info.var_id,
             "sid": self.__register_info.scope_id,
         }
@@ -137,6 +138,9 @@ class WebComputed(
     def _to_observable_config(self):
         return self.__to_binding_config()
 
+    def _to_event_input_type(self) -> InputBindingType:
+        return InputBindingType.Ref
+
 
 def web_computed(
     *,

instaui/watch/js_watch.py

@@ -5,7 +5,7 @@ from . import _utils
 from instaui.common.jsonable import Jsonable
 from instaui.runtime._app import get_current_scope
 
-from instaui.vars.mixin_types.py_binding import CanOutputMixin
+from instaui.vars.mixin_types.py_binding import CanOutputMixin, outputs_to_config
 from instaui.vars.mixin_types.common_type import TObservableInput
 from instaui._helper import observable_helper
 
@@ -23,14 +23,12 @@ class JsWatch(Jsonable):
     ) -> None:
         inputs = observable_helper.auto_made_inputs_to_slient(inputs, outputs)
 
-        get_current_scope().register_js_watch(self)
-
         self.code = code
 
         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 outputs or []]
+        self._outputs = [output for output in outputs or []]
 
         if immediate is not True:
             self.immediate = immediate
@@ -58,7 +56,7 @@ class JsWatch(Jsonable):
             data["data"] = self._is_data
 
         if self._outputs:
-            data["outputs"] = self._outputs
+            data["outputs"] = outputs_to_config(self._outputs)
 
         return data
 
@@ -107,4 +105,6 @@ def js_watch(
         ui.label(msg)
     """
 
-    return JsWatch(code, inputs, outputs, immediate, deep, once, flush)
+    watch = JsWatch(code, inputs, outputs, immediate, deep, once, flush)
+    get_current_scope().register_js_watch(watch)
+    return watch

instaui/watch/vue_watch.py

@@ -29,8 +29,6 @@ class VueWatch(Jsonable):
         once: bool = False,
         flush: Optional[_types.TFlush] = None,
     ) -> None:
-        get_current_scope().register_vue_watch(self)
-
         self.code = callback
 
         if not isinstance(sources, Sequence):
@@ -75,3 +73,28 @@ class VueWatch(Jsonable):
 
         if flush is not None:
             self.flush = flush
+
+
+def vue_watch(
+    sources: Union[Any, Sequence],
+    callback: str,
+    *,
+    bindings: Optional[Dict[str, Any]] = None,
+    immediate: bool = False,
+    deep: Union[bool, int] = False,
+    once: bool = False,
+    flush: Optional[_types.TFlush] = None,
+):
+    """ """
+
+    watch = VueWatch(
+        sources,
+        callback,
+        bindings=bindings,
+        immediate=immediate,
+        deep=deep,
+        once=once,
+        flush=flush,
+    )
+    get_current_scope().register_vue_watch(watch)
+    return watch

instaui/watch/web_watch.py

@@ -9,7 +9,11 @@ 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.mixin_types.py_binding import CanOutputMixin
+from instaui.vars.mixin_types.py_binding import (
+    CanOutputMixin,
+    outputs_to_config,
+    _assert_outputs_be_can_output_mixin,
+)
 from instaui.vars.mixin_types.common_type import TObservableInput
 from instaui._helper import observable_helper
 from instaui import pre_setup as _pre_setup
@@ -36,15 +40,18 @@ class WebWatch(Jsonable, typing.Generic[P, R]):
     ) -> None:
         if pre_setup:
             _pre_setup._check_args(pre_setup)
-        inputs = observable_helper.auto_made_inputs_to_slient(inputs, outputs)
 
-        get_current_scope().register_web_watch(self)
+        outputs = [] if outputs is None else outputs
+
+        _assert_outputs_be_can_output_mixin(outputs)
+
+        inputs = observable_helper.auto_made_inputs_to_slient(inputs, outputs)
 
         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 outputs or []]
+        self._outputs = outputs
         self._fn = func
         self._immediate = immediate
         self._deep = deep
@@ -86,7 +93,7 @@ class WebWatch(Jsonable, typing.Generic[P, R]):
                 data["debug"] = self._debug
 
             if self._outputs:
-                data["outputs"] = self._outputs
+                data["outputs"] = outputs_to_config(self._outputs)
 
             if self._immediate is not True:
                 data["immediate"] = self._immediate
@@ -171,7 +178,7 @@ def watch(
     """
 
     def wrapper(func: typing.Callable[P, R]):
-        return WebWatch(
+        obj = WebWatch(
             func,
             inputs,
             outputs=outputs,
@@ -183,4 +190,6 @@ def watch(
             _debug=_debug,
         )
 
+        get_current_scope().register_web_watch(obj)
+
     return wrapper

{instaui-0.2.1.dist-info → instaui-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: instaui
-Version: 0.2.1
+Version: 0.3.0
 Summary: insta-ui is a Python-based UI library for rapidly building user interfaces.
 Author-email: CrystalWindSnake <568166495@qq.com>
 License-Expression: MIT