instaui 0.1.0__py3-none-any.whl

instaui/components/vfor.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+from typing import (
+    Dict,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Union,
+    Sequence,
+    Generic,
+    TypeVar,
+    overload,
+)
+import pydantic
+
+from instaui.components.component import Component
+from instaui.vars.vfor_item import VForItem, VForDict, VForWithIndex
+from instaui.runtime._app import get_app_slot, new_scope
+
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+_T = TypeVar("_T")
+
+
+class VFor(Component, Generic[_T]):
+    def __init__(
+        self,
+        data: Union[Sequence[_T], ElementBindingMixin[List[_T]]],
+        *,
+        key: Union[Literal["item", "index"], str] = "index",
+    ):
+        """for loop component.
+
+        Args:
+            data (Union[Sequence[_T], ElementBindingMixin[List[_T]]]): data source.
+            key (Union[Literal["item", "index"], str]]): key for each item. Defaults to 'index'.
+
+        Examples:
+        .. code-block:: python
+            items = ui.state([1,2,3])
+
+            with ui.vfor(items) as item:
+                html.span(item)
+
+            # object key
+            items = ui.state([{"name": "Alice", "age": 20}, {"name": "Bob", "age": 30}])
+            with ui.vfor(items, key=":item=>item.name") as item:
+                html.span(item.name)
+        """
+
+        super().__init__("vfor")
+        self._data = data
+        self._key = key
+        self._fid = get_app_slot().generate_vfor_id()
+        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope = None
+        self._num = None
+        self._transition_group_setting = None
+
+    def __enter__(self) -> _T:
+        self.__scope = self.__scope_manager.__enter__()
+        super().__enter__()
+        return VForItem(self).proxy
+
+    def __exit__(self, *_) -> None:
+        self.__scope_manager.__exit__(*_)
+        return super().__exit__(*_)
+
+    def _set_num(self, num):
+        self._num = num
+
+    def transition_group(self, name="fade", tag: Optional[str] = None):
+        self._transition_group_setting = {"name": name, "tag": tag}
+        return self
+
+    @property
+    def current(self):
+        return VForItem(self)
+
+    def with_index(self):
+        return VForWithIndex(self)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["props"] = {"fid": self._fid}
+
+        props: Dict = data["props"]
+        if self._key is not None and self._key != "index":
+            props["fkey"] = self._key
+
+        if self._data is not None:
+            if isinstance(self._data, ElementBindingMixin):
+                props["bArray"] = self._data._to_element_binding_config()
+            else:
+                props["array"] = self._data
+
+        if self._num is not None:
+            props["num"] = self._num
+
+        if self._transition_group_setting is not None:
+            props["tsGroup"] = {
+                k: v for k, v in self._transition_group_setting.items() if v is not None
+            }
+
+        props["scope"] = self.__scope
+
+        if self._slot_manager.has_slot():
+            props["items"] = self._slot_manager
+
+        data.pop("slots", None)
+
+        return data
+
+    @overload
+    @classmethod
+    def range(cls, end: int) -> VFor[int]: ...
+
+    @overload
+    @classmethod
+    def range(cls, end: ElementBindingMixin[int]) -> VFor[int]: ...
+
+    @classmethod
+    def range(cls, end: Union[int, ElementBindingMixin[int]]) -> VFor[int]:
+        obj = cls(None)  # type: ignore
+
+        num = (  # type: ignore
+            end._to_element_binding_config()
+            if isinstance(end, ElementBindingMixin)
+            else end
+        )
+
+        obj._set_num(num)
+
+        return obj  # type: ignore
+
+    @classmethod
+    def from_dict(
+        cls, data: Union[Mapping, pydantic.BaseModel, ElementBindingMixin[Dict]]
+    ):
+        return VForDict(VFor(data))  # type: ignore

instaui/components/vif.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import Dict, cast
+from instaui.components.component import Component
+from instaui.runtime._app import new_scope
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.types import TMaybeRef
+
+
+class VIf(Component):
+    def __init__(self, on: TMaybeRef[bool]):
+        super().__init__("vif")
+        self._on = cast(ElementBindingMixin, on)
+        self.__scope_manager = new_scope(append_to_app=False)
+        self.__scope = None
+
+    def __enter__(self):
+        self.__scope = self.__scope_manager.__enter__()
+        return super().__enter__()
+
+    def __exit__(self, *_) -> None:
+        self.__scope_manager.__exit__(*_)
+        return super().__exit__(*_)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["props"] = {
+            "on": self._on._to_element_binding_config(),
+        }
+        props: Dict = data["props"]
+
+        props["scope"] = self.__scope
+
+        if self._slot_manager.has_slot():
+            props["items"] = self._slot_manager
+
+        data.pop("slots", None)
+
+        return data

instaui/consts.py

@@ -0,0 +1,18 @@
+from pathlib import Path
+from typing import Literal
+
+_THIS_DIR = Path(__file__).parent
+_TEMPLATES_DIR = _THIS_DIR.joinpath("templates")
+_STATIC_DIR = _THIS_DIR.joinpath("static")
+
+INDEX_TEMPLATE_PATH = _TEMPLATES_DIR.joinpath("index.html")
+APP_IIFE_JS_PATH = _STATIC_DIR.joinpath("insta-ui.iife.js")
+APP_ES_JS_PATH = _STATIC_DIR.joinpath("insta-ui.esm-browser.prod.js")
+APP_CSS_PATH = _STATIC_DIR.joinpath("insta-ui.css")
+VUE_IIFE_JS_PATH = _STATIC_DIR.joinpath("vue.global.prod.js")
+VUE_ES_JS_PATH = _STATIC_DIR.joinpath("vue.esm-browser.prod.js")
+VUE_ES_RUNTIME_JS_PATH = _STATIC_DIR.joinpath("vue.runtime.esm-browser.prod.js")
+TAILWIND_JS_PATH = _STATIC_DIR.joinpath("tailwindcss.min.js")
+
+_T_App_Mode = Literal["zero", "web", "webview"]
+TModifier = Literal["trim", "number", "lazy"]

instaui/dependencies/__init__.py

@@ -0,0 +1,15 @@
+from .component_registrar import (
+    ComponentRegistrationInfo,
+    register_component,
+    PluginRegistrationInfo,
+    register_plugin,
+)
+from .installer import install_component
+
+__all__ = [
+    "ComponentRegistrationInfo",
+    "register_component",
+    "PluginRegistrationInfo",
+    "register_plugin",
+    "install_component",
+]

instaui/dependencies/component_registrar.py

@@ -0,0 +1,82 @@
+import inspect
+from pathlib import Path
+from typing import List, Optional, Type, Union
+from instaui.systems.file_system import generate_hash_name_from_path
+from dataclasses import dataclass, field
+from instaui.runtime import get_app_slot
+from instaui.runtime._app import App
+
+
+class ComponentRegistrar:
+    def __init__(self, js_file: Path):
+        self.js_file = js_file
+        self.key = f"{generate_hash_name_from_path(js_file.parent)}/{js_file.name}"
+        self.name = js_file.stem
+
+    def __hash__(self) -> int:
+        return hash(self.js_file)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, ComponentRegistrar):
+            return False
+        return self.js_file == other.js_file
+
+    @classmethod
+    def create(cls, js_file: Union[str, Path], target_class: Type):
+        js_file = Path(js_file)
+        base = Path(inspect.getfile(target_class)).parent
+        if not js_file.is_absolute():
+            js_file = base / js_file
+        return cls(js_file)
+
+
+@dataclass(frozen=True)
+class ComponentRegistrationInfo:
+    name: str
+    esm: Optional[Path] = None
+    iife: Optional[Path] = None
+    css: List[Path] = field(default_factory=list, compare=False)
+
+
+@dataclass(frozen=True)
+class PluginRegistrationInfo:
+    name: str
+    esm: Optional[Path] = None
+    iife: Optional[Path] = None
+    css: List[Path] = field(default_factory=list, compare=False)
+
+
+def register_plugin(
+    name: str,
+    esm: Optional[Path] = None,
+    iife: Optional[Path] = None,
+    css: Optional[Union[Path, List[Path]]] = None,
+    shared: bool = False,
+):
+    css = [css] if isinstance(css, Path) else css
+
+    cr = PluginRegistrationInfo(name, esm, iife, css or [])
+
+    if shared:
+        App.default_plugins(cr)
+
+    get_app_slot().register_plugin(cr)
+    return cr
+
+
+def register_component(
+    name: str,
+    esm: Optional[Path] = None,
+    iife: Optional[Path] = None,
+    css: Optional[Union[Path, List[Path]]] = None,
+    shared: bool = False,
+):
+    css = [css] if isinstance(css, Path) else css
+
+    cr = ComponentRegistrationInfo(f"instaui-{name}", esm, iife, css or [])
+
+    if shared:
+        App.default_js_components(cr)
+
+    get_app_slot().register_component(cr)
+    return cr

instaui/dependencies/installer.py

@@ -0,0 +1,5 @@
+from typing import Callable
+
+
+def install_component(install: Callable):
+    install()

instaui/event/event_mixin.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+import typing
+
+
+class EventMixin(ABC):
+    @abstractmethod
+    def copy_with_extends(self, extends: typing.Sequence) -> "EventMixin":
+        pass
+
+    @abstractmethod
+    def event_type(self) -> typing.Literal["web", "js"]:
+        pass

instaui/event/js_event.py

@@ -0,0 +1,57 @@
+import typing
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.common.jsonable import Jsonable
+from .event_mixin import EventMixin
+
+
+class JsEvent(Jsonable, EventMixin):
+    def __init__(
+        self,
+        code: str,
+        inputs: typing.Optional[typing.Sequence[CanInputMixin]] = None,
+        outputs: typing.Optional[typing.Sequence[CanOutputMixin]] = None,
+    ):
+        self._is_const_data = [
+            int(not isinstance(input, CanInputMixin)) for input in inputs or []
+        ]
+        self._org_inputs = list(inputs or [])
+        self._org_outputs = list(outputs or [])
+        self._inputs = [
+            input._to_input_config() if isinstance(input, CanInputMixin) else input
+            for input in inputs or []
+        ]
+        self._outputs = [output._to_output_config() for output in outputs or []]
+        self.code = code
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        if self._inputs:
+            data["inputs"] = self._inputs
+
+        if self._outputs:
+            data["set"] = self._outputs
+
+        if sum(self._is_const_data) > 0:
+            data["data"] = self._is_const_data
+
+        return data
+
+    def copy_with_extends(self, extends: typing.Sequence):
+        return js_event(
+            code=self.code,
+            inputs=self._org_inputs + list(extends),
+            outputs=self._org_outputs,
+        )
+
+    def event_type(self):
+        return "js"
+
+
+def js_event(
+    *,
+    inputs: typing.Optional[typing.Sequence] = None,
+    outputs: typing.Optional[typing.Sequence] = None,
+    code: str,
+):
+    return JsEvent(inputs=inputs, outputs=outputs, code=code)

instaui/event/web_event.py

@@ -0,0 +1,108 @@
+import inspect
+import typing
+from typing_extensions import ParamSpec
+from instaui.common.jsonable import Jsonable
+from instaui.runtime._app import get_current_scope, get_app_slot
+from instaui.vars.mixin_types.py_binding import CanInputMixin, CanOutputMixin
+from instaui.handlers import event_handler
+from .event_mixin import EventMixin
+
+
+P = ParamSpec("P")
+R = typing.TypeVar("R")
+_T_input = typing.TypeVar("_T_input")
+_T_output = typing.TypeVar("_T_output")
+
+
+class WebEvent(Jsonable, EventMixin, typing.Generic[P, R]):
+    def __init__(
+        self,
+        fn: typing.Callable[P, R],
+        inputs: typing.List[CanInputMixin],
+        outputs: typing.List[CanOutputMixin],
+    ):
+        self._inputs = inputs
+        self._outputs = outputs
+        self._fn = fn
+
+        scope = get_current_scope()
+        self._sid = scope.id
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        return self._fn(*args, **kwargs)
+
+    def copy_with_extends(self, extends: typing.Sequence[CanInputMixin]):
+        return WebEvent(
+            fn=self._fn,
+            inputs=self._inputs + list(extends),
+            outputs=self._outputs,
+        )
+
+    def event_type(self):
+        return "web"
+
+    def _to_json_dict(self):
+        app = get_app_slot()
+
+        hkey = event_handler.create_handler_key(
+            page_path=app.page_path, handler=self._fn
+        )
+
+        handler_path = (
+            event_handler.ASYNC_URL
+            if inspect.iscoroutinefunction(self._fn)
+            else event_handler.SYNC_URL
+        )
+
+        event_handler.register_event_handler(
+            hkey, self._fn, self._outputs, self._inputs
+        )
+
+        data = {}
+        data["url"] = handler_path
+        data["hKey"] = hkey
+        data["sid"] = self._sid
+
+        if self._inputs:
+            data["bind"] = [
+                binding._to_input_config()
+                if isinstance(binding, CanInputMixin)
+                else binding
+                for binding in self._inputs
+            ]
+
+        if self._outputs:
+            data["set"] = [ref._to_output_config() for ref in self._outputs]
+
+        return data
+
+
+@typing.overload
+def ui_event(fn: typing.Callable[P, R]) -> WebEvent[P, R]: ...
+
+
+@typing.overload
+def ui_event(
+    *,
+    inputs: typing.Optional[typing.Union[_T_input, typing.Sequence[_T_input]]] = None,
+    outputs: typing.Optional[
+        typing.Union[_T_output, typing.Sequence[_T_output]]
+    ] = None,
+) -> typing.Callable[[typing.Callable[P, R]], WebEvent[P, R]]: ...
+
+
+def ui_event(
+    fn: typing.Optional[typing.Callable[P, R]] = None, *, inputs=None, outputs=None
+) -> typing.Union[
+    WebEvent[P, R], typing.Callable[[typing.Callable[P, R]], WebEvent[P, R]]
+]:
+    inputs = [inputs] if isinstance(inputs, CanInputMixin) else inputs
+    outputs = [outputs] if isinstance(outputs, CanOutputMixin) else outputs
+    if fn is None:
+
+        def wrapper(fn: typing.Callable[P, R]):
+            return WebEvent(fn, inputs=inputs or [], outputs=outputs or [])
+
+        return wrapper
+
+    return WebEvent(fn, inputs=inputs or [], outputs=outputs or [])

instaui/experimental/__init__.py

@@ -0,0 +1,4 @@
+from .debug import list_all_bindables
+from instaui.vars.state import state
+
+__all__ = ["list_all_bindables", "state"]

instaui/experimental/debug.py

@@ -0,0 +1,48 @@
+from typing import Dict
+from instaui import ui
+from instaui.components import html
+from instaui.vars.mixin_types.observable import ObservableMixin
+
+
+def list_all_bindables(locals_dict: Dict):
+    """List all bindables in the locals() dictionary.
+
+
+    Example usage:
+
+    ```python
+    list_all_bindables(locals())
+    ```
+
+    """
+
+    with html.div().style(
+        "display: grid; grid-template-columns: auto 1fr; border: 1px solid black; padding: 10px;"
+    ):
+        html.label("variable name")
+        html.label("bindable value").style("justify-self: center;")
+
+        html.div().style(
+            "grid-column: 1 / span 2;height: 1px;border-bottom: 1px solid black;"
+        )
+
+        for key, value in locals_dict.items():
+            if isinstance(value, ObservableMixin):
+                cp_value = ui.js_computed(
+                    inputs=[value],
+                    code=r"""(obj)=>{
+ 
+    if (typeof obj === 'object') {
+        if (obj === null) {
+            return 'null';
+        } else {
+            return JSON.stringify(obj);
+        }
+    } else {
+        return String(obj);
+    }
+}""",
+                )
+
+                html.paragraph(f"{key}:").style("justify-self: end;")
+                html.paragraph(cp_value).style("justify-self: center;")

instaui/fastapi_server/_utils.py

@@ -0,0 +1,42 @@
+from typing import Any, Dict, List, Optional
+from instaui.runtime._app import get_app_slot
+from instaui.skip import is_skip_output
+import pydantic
+
+
+class ResponseData(pydantic.BaseModel):
+    values: Optional[List[Any]] = None
+    skips: Optional[List[int]] = None
+
+
+def update_app_page_info(data: Dict):
+    app = get_app_slot()
+
+    page_info = data.get("page", {})
+    app._page_path = page_info["path"]
+
+    if "params" in page_info:
+        app._page_params = page_info["params"]
+
+    if "queryParams" in page_info:
+        app._query_params = page_info["queryParams"]
+
+
+def response_data(outputs_binding_count: int, result: Any):
+    data = ResponseData()
+    if outputs_binding_count > 0:
+        if not isinstance(result, tuple):
+            result = [result]
+
+        result_infos = [(r, int(is_skip_output(r))) for r in result]
+
+        if len(result_infos) == 1 and result_infos[0][1] == 1:
+            return data
+
+        data.values = [0 if info[1] == 1 else info[0] for info in result_infos]
+        skips = [info[1] for info in result_infos]
+
+        if sum(skips) > 0:
+            data.skips = skips
+
+    return data

instaui/fastapi_server/_uvicorn.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from types import FrameType
+import typing
+import uvicorn
+import socket
+
+
+ThandleExitCallbacks = typing.List[typing.Callable[[], typing.Any]]
+
+
+class UvicornServer(uvicorn.Server):
+    instance: UvicornServer
+
+    def __init__(self, config: uvicorn.Config) -> None:
+        super().__init__(config)
+        self._handle_exit_callbacks: ThandleExitCallbacks = []
+
+    @classmethod
+    def create_singleton(
+        cls, config: uvicorn.Config, handle_exit_callbacks: ThandleExitCallbacks
+    ) -> None:
+        cls.instance = cls(config=config)
+        for callback in handle_exit_callbacks:
+            cls.instance.on_handle_exit(callback)
+
+    def run(self, sockets: typing.Optional[typing.List[socket.socket]] = None) -> None:
+        self.instance = self
+
+        super().run()
+
+    def on_handle_exit(self, callback: typing.Callable[[], typing.Any]):
+        self._handle_exit_callbacks.append(callback)
+
+    def handle_exit(self, sig: int, frame: FrameType | None) -> None:
+        for callback in self._handle_exit_callbacks:
+            callback()
+        return super().handle_exit(sig, frame)

instaui/fastapi_server/config_router.py

@@ -0,0 +1,60 @@
+from typing import Dict
+from fastapi import FastAPI
+from contextlib import contextmanager
+from instaui.html_tools import to_config_data
+from instaui.handlers import config_handler
+from instaui.launch_collector import get_launch_collector
+from . import _utils
+
+
+def create_router(app: FastAPI):
+    _async_config_handler(app)
+    _sync_config_handler(app)
+
+
+def _async_config_handler(app: FastAPI):
+    @app.post(config_handler.ASYNC_URL)
+    async def _(data: Dict):
+        key = data.get("key", None)
+        handler = config_handler.get_handler(key)
+        if handler is None:
+            return {"error": "event handler not found"}
+
+        _utils.update_app_page_info(data)
+
+        with _execute_request_lifespans():
+            await handler()
+
+        return to_config_data()
+
+
+def _sync_config_handler(app: FastAPI):
+    @app.post(config_handler.SYNC_URL)
+    def _(data: Dict):
+        key = data.get("key", None)
+
+        handler = config_handler.get_handler(key)
+        if handler is None:
+            return {"error": "event handler not found"}
+
+        _utils.update_app_page_info(data)
+
+        with _execute_request_lifespans():
+            handler()
+
+        return to_config_data()
+
+
+@contextmanager
+def _execute_request_lifespans():
+    events = [iter(event()) for event in get_launch_collector().page_request_lifespans]
+    for event in events:
+        next(event)
+
+    yield
+
+    for event in events:
+        try:
+            next(event)
+        except StopIteration:
+            pass