instaui 0.1.15__py2.py3-none-any.whl

instaui/ui_functions/url_location.py

@@ -0,0 +1,33 @@
+from urllib.parse import quote_plus
+
+
+class UrlLocation:
+    @staticmethod
+    def goto(url: str, **params):
+        url = _url_with_params(url, **params)
+        return f'window.location.href = "{url}"'
+
+    @staticmethod
+    def replace(url: str, **params):
+        url = _url_with_params(url, **params)
+        return f'window.location.replace("{url}")'
+
+    @staticmethod
+    def back():
+        return "window.history.back()"
+
+    @staticmethod
+    def forward():
+        return "window.history.forward()"
+
+    @staticmethod
+    def reload():
+        return "window.history.go(0)"
+
+
+def _url_with_params(url: str, **params):
+    url_params = "&".join([f"{k}={v}" for k, v in params.items()])
+    if url_params:
+        url += f"?{url_params}"
+
+    return quote_plus(url, safe=":/?=&")

instaui/vars/_types.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+from typing import Literal, TypeVar
+
+
+_T_Value = TypeVar("_T_Value")
+_T_Output_Value = TypeVar("_T_Output_Value", covariant=True)
+_T_VAR_TYPE = Literal["ref", "computed", "webComputed"]
+_T_Bindable_Type = Literal["ref", "computed", "js", "webComputed", "vforItem"]

instaui/vars/data.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+from typing import (
+    Any,
+    Dict,
+)
+
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_current_scope
+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.element_binding import ElementBindingMixin
+from .mixin_types.pathable import CanPathPropMixin
+from .mixin_types.str_format_binding import StrFormatBindingMixin
+
+
+class ConstData(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    CanInputMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    BIND_TYPE = "var"
+
+    def __init__(self, value: Any = None) -> None:
+        self.value = value  # type: ignore
+
+        scope = get_current_scope()
+        scope.register_data(self)
+        self._sid = scope.id
+        self._id = scope.generate_vars_id()
+
+    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_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
+
+        return data
+
+
+TConstData = ConstData

instaui/vars/element_ref.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_current_scope
+from instaui.vars.mixin_types.py_binding import CanOutputMixin
+
+
+class ElementRef(Jsonable, CanOutputMixin):
+    def __init__(self) -> None:
+        scope = get_current_scope()
+        self._id = scope.generate_element_ref_id()
+        self.__sid = get_current_scope().id
+
+    def __to_binding_config(
+        self,
+    ):
+        return {
+            "type": "ele_ref",
+            "id": self._id,
+            "sid": self.__sid,
+        }
+
+    def _to_output_config(self):
+        return self.__to_binding_config()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["id"] = self._id
+        data["sid"] = self.__sid
+
+        return data
+
+    def _to_element_config(self):
+        return {"id": self._id, "sid": self.__sid}
+
+
+def run_element_method(method_name: str, *args, **kwargs):
+    return {
+        "method": method_name,
+        "args": args,
+    }

instaui/vars/event_context.py

@@ -0,0 +1,49 @@
+from typing import Dict
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.py_binding import CanInputMixin
+
+
+class EventContext(Jsonable, CanInputMixin):
+    _TYPE = "event"
+
+    def __init__(self, path: str):
+        self.path = path
+
+    def _to_input_config(self):
+        return self._to_binding_config()
+
+    def _to_binding_config(self) -> Dict:
+        return {
+            "type": self._TYPE,
+            "path": self.path,
+        }
+
+    @staticmethod
+    def dataset(name="eventData"):
+        return DatasetEventContext(EventContext(f":e=> e.target.dataset.{name}"))
+
+    @staticmethod
+    def args():
+        return EventContext(":(...e)=> e")
+
+    @staticmethod
+    def e():
+        return EventContext(":e => e")
+
+    @staticmethod
+    def target_value():
+        return EventContext(":e => e.target.value")
+
+
+class DatasetEventContext(Jsonable, CanInputMixin):
+    def __init__(self, event_context: EventContext) -> None:
+        self._event_context = event_context
+
+    def _to_input_config(self):
+        return self._to_binding_config()
+
+    def _to_binding_config(self) -> Dict:
+        return self._event_context._to_binding_config()
+
+    def _to_json_dict(self):
+        return self._event_context._to_json_dict()

instaui/vars/js_computed.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+import typing
+
+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
+from instaui.vars.mixin_types.common_type import TObservableInput
+from instaui._helper import observable_helper
+
+
+class JsComputed(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    ObservableMixin,
+    CanInputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    """
+    A client-side computed property that evaluates JavaScript code to derive reactive values.
+
+    Args:
+        inputs (typing.Optional[typing.Sequence[TObservableInput]], optional): Reactive data sources to monitor.
+                                                  Changes to these values trigger re-computation.
+        code (str): JavaScript code to execute for computing the value.
+        async_init_value (typing.Optional[typing.Any], optional): Initial value to use before first successful async evaluation.
+
+    # Example:
+    .. code-block:: python
+        a = ui.state(0)
+
+        plus_one = ui.js_computed(inputs=[a], code="a=> a+1")
+
+        html.number(a)
+        ui.label(plus_one)
+    """
+
+    BIND_TYPE = "var"
+
+    def __init__(
+        self,
+        *,
+        inputs: typing.Optional[typing.Sequence[TObservableInput]] = None,
+        code: str,
+        async_init_value: typing.Optional[typing.Any] = None,
+        deep_compare_on_input: bool = False,
+    ) -> None:
+        self.code = code
+
+        scope = get_current_scope()
+        scope.register_js_computed(self)
+        self._sid = scope.id
+        self._id = scope.generate_vars_id()
+
+        self._inputs, self._is_slient_inputs, self._is_data = (
+            observable_helper.analyze_observable_inputs(list(inputs or []))
+        )
+
+        self._async_init_value = async_init_value
+        self._deep_compare_on_input = deep_compare_on_input
+
+    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) -> typing.Dict:
+        return self.__to_binding_config()
+
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
+
+    def _to_pathable_binding_config(self) -> typing.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
+
+        if self._inputs:
+            data["inputs"] = self._inputs
+
+        if sum(self._is_slient_inputs) > 0:
+            data["slient"] = self._is_slient_inputs
+
+        if sum(self._is_data) > 0:
+            data["data"] = self._is_data
+
+        if self._async_init_value is not None:
+            data["asyncInit"] = self._async_init_value
+
+        if self._deep_compare_on_input is not False:
+            data["deepEqOnInput"] = 1
+
+        return data
+
+
+TJsComputed = JsComputed

instaui/vars/mixin_types/common_type.py

@@ -0,0 +1,5 @@
+from typing import Union, Any
+from .observable import ObservableMixin
+from .py_binding import CanInputMixin
+
+TObservableInput = Union[ObservableMixin, CanInputMixin, Any]

instaui/vars/mixin_types/element_binding.py

@@ -0,0 +1,16 @@
+from typing import Dict, Generic, TypeVar
+from abc import ABC, abstractmethod
+
+T = TypeVar("T")
+
+
+class ElementBindingMixin(ABC, Generic[T]):
+    @abstractmethod
+    def _to_element_binding_config(self) -> Dict:
+        pass
+
+    def _mark_used(self):
+        pass
+
+    def _is_used(self):
+        return True

instaui/vars/mixin_types/observable.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+
+
+class ObservableMixin(ABC):
+    @abstractmethod
+    def _to_observable_config(self):
+        pass

instaui/vars/mixin_types/pathable.py

@@ -0,0 +1,14 @@
+from typing import Dict
+from abc import ABC, abstractmethod
+
+
+class PathableMixin(ABC):
+    @abstractmethod
+    def _to_pathable_binding_config(self) -> Dict:
+        pass
+
+
+class CanPathPropMixin(ABC):
+    @abstractmethod
+    def _to_path_prop_binding_config(self) -> Dict:
+        pass

instaui/vars/mixin_types/py_binding.py

@@ -0,0 +1,13 @@
+from abc import ABC, abstractmethod
+
+
+class CanInputMixin(ABC):
+    @abstractmethod
+    def _to_input_config(self):
+        pass
+
+
+class CanOutputMixin(ABC):
+    @abstractmethod
+    def _to_output_config(self):
+        pass

instaui/vars/mixin_types/str_format_binding.py

@@ -0,0 +1,8 @@
+from typing import Tuple
+from abc import ABC
+
+
+class StrFormatBindingMixin(ABC):
+    def _to_str_format_binding(self, order: int) -> Tuple[str, str]:
+        var_name = f"___ref_var{order}"
+        return var_name, f"${{__Vue.toValue({var_name})}}"

instaui/vars/mixin_types/var_type.py

@@ -0,0 +1,5 @@
+from abc import ABC
+
+
+class VarMixin(ABC):
+    pass

instaui/vars/path_var.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+from abc import abstractmethod
+from typing import List, Optional, Union
+from typing_extensions import 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.runtime._app import get_current_scope
+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
+
+
+_T_Value = TypeVar("_T_Value")
+
+
+class Ref(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    ObservableMixin,
+    CanInputMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin[_T_Value],
+    Generic[_T_Value],
+):
+    VAR_TYPE = "var"
+
+    def __init__(self, value: Optional[_T_Value] = None) -> None:
+        self.value = value  # type: ignore
+        scope = get_current_scope()
+        scope.register_ref(self)
+
+        self._sid = scope.id
+        self._id = scope.generate_vars_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
+
+        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()