instaui 0.1.0__py3-none-any.whl

instaui/ui/__init__.py

@@ -0,0 +1,121 @@
+from instaui.version import __version__
+from instaui.vars import TMaybeRef
+from instaui.vars.ref import ref, TRef
+
+from instaui.vars.data import ConstData as data, TConstData
+from instaui.vars.js_computed import JsComputed as js_computed, TJsComputed
+from instaui.vars.vue_computed import VueComputed as vue_computed, TVueComputed
+from instaui.vars.web_computed import web_computed as computed, TComputed
+from instaui.vars.state import state, StateModel
+from instaui.inject import inject_state, provide_state, injection_key
+from instaui.vars.vfor_item import TVForItem, TVForIndex
+from instaui.vars.element_ref import ElementRef as element_ref, run_element_method
+from instaui.html_tools import (
+    to_json,
+    to_html,
+    add_css_link,
+    add_js_link,
+    add_style,
+    add_js_code,
+    add_vue_app_use,
+    to_config_data,
+)
+
+
+from instaui.components.element import Element as element
+from instaui.components.row import Row as row
+from instaui.components.column import Column as column
+from instaui.components.grid import Grid as grid
+from instaui.components.directive import Directive as directive
+from instaui.components.vfor import VFor as vfor
+from instaui.components.vif import VIf as vif
+from instaui.components.match import Match as match
+from instaui.components.content import Content as content
+from instaui.dependencies import install_component
+
+from instaui.event.web_event import ui_event as event, WebEvent as TEventFn
+from instaui.event.js_event import js_event
+from instaui.vars.event_context import EventContext as event_context
+from instaui.runtime.context import get_context as context
+
+import instaui.js as js
+from instaui.watch.web_watch import watch
+from instaui.watch.vue_watch import VueWatch as vue_watch
+from instaui.watch.js_watch import js_watch
+from instaui.handlers.watch_handler import WatchState as TWatchState
+from instaui.skip import skip_output
+from instaui.ui_functions.input_slient_data import InputSilentData as slient
+from instaui.js.js_output import JsOutput as js_output
+import instaui.experimental as experimental
+
+
+from instaui.ui_functions.server import create_server as server
+from instaui.ui_functions.ui_page import page
+from instaui.ui_functions.url_location import UrlLocation as url_location
+from instaui.ui_functions.str_format import str_format
+from instaui.ui_functions.ui_types import TBindable, is_bindable
+
+from .events import on_page_request_lifespan
+
+__all__ = [
+    "__version__",
+    "TMaybeRef",
+    "TBindable",
+    "is_bindable",
+    "ref",
+    "slient",
+    "data",
+    "TConstData",
+    "TRef",
+    "vue_computed",
+    "TVueComputed",
+    "js_computed",
+    "TJsComputed",
+    "computed",
+    "TComputed",
+    "state",
+    "StateModel",
+    "inject_state",
+    "provide_state",
+    "injection_key",
+    "TVForItem",
+    "TVForIndex",
+    "element_ref",
+    "run_element_method",
+    "to_json",
+    "to_html",
+    "to_config_data",
+    "element",
+    "vfor",
+    "content",
+    "add_style",
+    "add_css_link",
+    "add_js_code",
+    "add_js_link",
+    "add_vue_app_use",
+    "install_component",
+    "directive",
+    "vif",
+    "page",
+    "event",
+    "js_event",
+    "event_context",
+    "TEventFn",
+    "server",
+    "context",
+    "row",
+    "grid",
+    "js",
+    "watch",
+    "vue_watch",
+    "js_watch",
+    "TWatchState",
+    "match",
+    "column",
+    "experimental",
+    "skip_output",
+    "js_output",
+    "str_format",
+    "url_location",
+    "on_page_request_lifespan",
+]

instaui/ui/events.py

@@ -0,0 +1,25 @@
+from typing import Callable
+from instaui.launch_collector import get_launch_collector
+
+
+def on_page_request_lifespan(fn: Callable):
+    """Register a function to be called on each page request.
+
+    Args:
+        fn (Callable): A function to be called on each page request.
+
+    Example:
+    .. code-block:: python
+        @ui.on_page_request_lifespan
+        def _():
+            print("page request start")
+            yield
+            print("page request end")
+
+        # can stop the lifespan by calling the returned function
+        stop_lifespan = ui.on_page_request_lifespan(lambda: None)
+        stop_lifespan()
+    """
+
+    remove_key = get_launch_collector().add_page_request_lifespan(fn)
+    return lambda: get_launch_collector().remove_page_request_lifespan(remove_key)

instaui/ui_functions/input_slient_data.py

@@ -0,0 +1,16 @@
+import typing
+from instaui.vars.mixin_types.py_binding import CanInputMixin
+
+
+class InputSilentData(CanInputMixin):
+    def __init__(self, value: typing.Union[CanInputMixin, typing.Any]) -> None:
+        self.value = value
+
+    def is_const_value(self) -> bool:
+        return not isinstance(self.value, CanInputMixin)
+
+    def _to_input_config(self):
+        if isinstance(self.value, CanInputMixin):
+            return self.value._to_input_config()
+        else:
+            return self.value

instaui/ui_functions/server.py

@@ -0,0 +1,13 @@
+from instaui.runtime.context import get_context
+
+
+def create_server(
+    debug: bool = True,
+):
+    from instaui.fastapi_server.server import Server
+
+    context = get_context()
+    context._app_mode = "web"
+    context._debug_mode = debug
+
+    return Server.get_instance()

instaui/ui_functions/str_format.py

@@ -0,0 +1,36 @@
+from typing import cast
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.vue_computed import VueComputed
+
+
+def str_format(template: str, *args, **kwargs):
+    bindings = {}
+
+    tran_args = []
+
+    for idx, arg in enumerate(args):
+        is_mixin = isinstance(arg, StrFormatBindingMixin)
+        value = (
+            cast(StrFormatBindingMixin, arg)._to_str_format_binding(idx)
+            if is_mixin
+            else arg
+        )
+        tran_args.append(value[-1] if is_mixin else value)
+        if is_mixin:
+            bindings[value[0]] = arg
+
+    tran_kwargs = {}
+
+    for idx, (k, v) in enumerate(kwargs.items()):
+        is_mixin = isinstance(v, StrFormatBindingMixin)
+        value = (
+            cast(StrFormatBindingMixin, v)._to_str_format_binding(idx)
+            if is_mixin
+            else v
+        )
+        tran_kwargs[k] = value[-1] if is_mixin else value
+        if is_mixin:
+            bindings[value[0]] = v
+
+    code = "()=>`" + template.format(*tran_args, **tran_kwargs) + "`"
+    return VueComputed(code, bindings=bindings)

instaui/ui_functions/ui_page.py

@@ -0,0 +1,31 @@
+import inspect
+from typing import Callable, Optional
+from instaui.launch_collector import get_launch_collector, PageInfo
+
+
+def page(
+    url: str,
+    *,
+    page_loading: Optional[Callable] = None,
+    use_tailwind: Optional[bool] = None,
+):
+    """Register a page route.
+
+    Args:
+        url (str): The route URL.
+        page_loading (Optional[Callable], optional): Function to display a preload interface for the page. Defaults to None.
+        use_tailwind (Optional[bool], optional): Whether to use tailwind or not. Defaults to None(not use tailwind).
+
+    Raises:
+        ValueError:  if page_loading_fn is a coroutine function
+    """
+    if page_loading is not None and inspect.iscoroutinefunction(page_loading):
+        raise ValueError("page_loading_fn must be a synchronous function")
+
+    def wrapper(func: Callable):
+        get_launch_collector().register_page(
+            PageInfo(url, func, page_loading, use_tailwind=use_tailwind)
+        )
+        return func
+
+    return wrapper

instaui/ui_functions/ui_types.py

@@ -0,0 +1,13 @@
+from typing import Any, TypeVar, Union
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+_T = TypeVar("_T")
+
+
+def is_bindable(obj: Any):
+    return isinstance(obj, (CanInputMixin, CanOutputMixin,ObservableMixin, ElementBindingMixin))
+
+
+TBindable = Union[CanInputMixin, CanOutputMixin,ObservableMixin, ElementBindingMixin[_T]]

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/__init__.py

@@ -0,0 +1,13 @@
+from .ref import Ref
+from .web_computed import WebComputed
+from .vfor_item import VForItem
+from .types import TRefOrComputed, TMaybeRef
+
+
+__all__ = [
+    "Ref",
+    "WebComputed",
+    "TRefOrComputed",
+    "TMaybeRef",
+    "VForItem",
+]

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/_utils.py

@@ -0,0 +1,12 @@
+from instaui.runtime._app import get_current_scope
+from instaui.vars.mixin_types.var_type import VarMixin
+
+
+def register_var(object: VarMixin):
+    """
+    sid,id = register_var(object)
+    """
+    scope = get_current_scope()
+    scope.register_var(object)
+
+    return scope.id, scope.generate_vars_id()

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.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
+from . import _utils
+
+
+class ConstData(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    CanInputMixin,
+    CanOutputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    VAR_TYPE = "data"
+
+    def __init__(self, value: Any = None) -> None:
+        self.value = value  # type: ignore
+
+        sid, id = _utils.register_var(self)
+        self._sid = sid
+        self._id = id
+
+    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_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
+
+        return data
+
+
+TConstData = ConstData

instaui/vars/element_ref.py

@@ -0,0 +1,42 @@
+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:
+        self._id = None
+        self.__sid = get_current_scope().id
+
+    def _set_id(self, id: str):
+        self._id = 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,45 @@
+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")
+
+
+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,95 @@
+from __future__ import annotations
+import typing
+
+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 instaui.vars.mixin_types.common_type import TObservableInput
+from instaui._helper import observable_helper
+
+from . import _utils
+
+
+class JsComputed(
+    Jsonable,
+    PathVar,
+    VarMixin,
+    ObservableMixin,
+    CanInputMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    VAR_TYPE = "jsComputed"
+    BIND_TYPE = "computed"
+
+    def __init__(
+        self,
+        *,
+        inputs: typing.Optional[typing.Sequence[TObservableInput]] = None,
+        code: str = "",
+        async_init_value: typing.Optional[typing.Any] = None,
+    ) -> None:
+        self.code = code
+
+        sid, id = _utils.register_var(self)
+        self._sid = sid
+        self._id = 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
+
+    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
+        data["type"] = self.VAR_TYPE
+
+        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
+
+        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,10 @@
+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

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