instaui 0.1.15__py2.py3-none-any.whl

instaui/event/web_event.py

@@ -0,0 +1,123 @@
+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.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.handlers import event_handler
+from .event_mixin import EventMixin
+
+_SYNC_TYPE = "sync"
+_ASYNC_TYPE = "async"
+
+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.Sequence[CanInputMixin],
+        outputs: typing.Sequence[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=list(self._inputs) + list(extends),
+            outputs=self._outputs,
+        )
+
+    def event_type(self):
+        return "web"
+
+    def _to_json_dict(self):
+        app = get_app_slot()
+
+        for _input in self._inputs:
+            if isinstance(_input, ElementBindingMixin):
+                _input._mark_used()
+
+        hkey = event_handler.create_handler_key(
+            page_path=app.page_path, handler=self._fn
+        )
+
+        event_handler.register_event_handler(
+            hkey, self._fn, self._outputs, self._inputs
+        )
+
+        data = {}
+        data["type"] = self.event_type()
+        data["fType"] = (
+            _ASYNC_TYPE if inspect.iscoroutinefunction(self._fn) else _SYNC_TYPE
+        )
+        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
+
+
+def event(
+    *,
+    inputs: typing.Optional[typing.Sequence] = None,
+    outputs: typing.Optional[typing.Sequence] = None,
+):
+    """
+    Creates an event handler decorator for binding reactive logic to component events.
+
+    Args:
+        inputs (typing.Optional[typing.Sequence], optional): Reactive sources (state objects, computed properties)
+                                   that should be accessible during event handling.
+                                   These values will be passed to the decorated function
+                                   when the event fires.
+        outputs (typing.Optional[typing.Sequence], optional): Targets (state variables, UI elements) that should
+                                    update when this handler executes. Used for coordinating
+                                    interface updates after the event is processed.
+
+    # Example:
+    .. code-block:: python
+        from instaui import ui, html
+
+        a = ui.state(0)
+
+        @ui.event(inputs=[a], outputs=[a])
+        def plus_one(a):
+            return a + 1
+
+        html.button("click me").on_click(plus_one)
+        html.paragraph(a)
+
+    """
+
+    def wrapper(func: typing.Callable[P, R]):
+        return WebEvent(
+            func,
+            inputs or [],
+            outputs=outputs or [],
+        )
+
+    return wrapper

instaui/experimental/__init__.py

@@ -0,0 +1,3 @@
+from .debug import list_all_bindables
+
+__all__ = ["list_all_bindables"]

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/extra_libs/_echarts.py

@@ -0,0 +1,3 @@
+__all__ = ["echarts"]
+
+from instaui_echarts import echarts  # type: ignore

instaui/extra_libs/_import_error.py

@@ -0,0 +1,9 @@
+def show_error(msg: str):
+    def error_handler(error: Exception):
+        from instaui.components.html.paragraph import Paragraph
+
+        Paragraph(msg).style(
+            "border: 1px dashed red;padding: 1em;font-weight: bold;font-size: medium;"
+        )
+
+    return error_handler

instaui/extra_libs/_mermaid.py

@@ -0,0 +1,3 @@
+__all__ = ["mermaid"]
+
+from instaui_mermaid import Mermaid as mermaid  # type: ignore

instaui/extra_libs/_shiki_code.py

@@ -0,0 +1,3 @@
+__all__ = ["code"]
+
+from instaui_shiki import shiki as code  # type: ignore

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

@@ -0,0 +1,60 @@
+import asyncio
+import logging
+import typing
+from fastapi import FastAPI, Request, Depends
+from fastapi.responses import StreamingResponse
+from instaui.runtime.context import get_context
+import uuid
+
+DEBUG_SSE_URL = "/instaui/debug-sse"
+logger = logging.getLogger(__name__)
+
+_task_events: typing.Dict[str, asyncio.Event] = {}
+
+
+def create_router(app: FastAPI):
+    if get_context().debug_mode:
+        _create_sse(app)
+
+
+async def event_generator(
+    request: Request, connection_id: str, interval_heart_beat_sec: float = 0.8
+):
+    logger.debug("debug sse started")
+    task_event = asyncio.Event()
+    _task_events[connection_id] = task_event
+
+    try:
+        while not task_event.is_set():
+            if await request.is_disconnected():
+                break
+
+            yield "data:1\n\n"
+            await asyncio.sleep(interval_heart_beat_sec)
+
+    except asyncio.CancelledError:
+        pass
+    finally:
+        if connection_id in _task_events:
+            del _task_events[connection_id]
+
+
+def _get_connection_id(request: Request):
+    return str(uuid.uuid4())
+
+
+def _create_sse(app: FastAPI):
+    @app.get(DEBUG_SSE_URL)
+    async def events(
+        request: Request, connection_id: str = Depends(_get_connection_id)
+    ):
+        return StreamingResponse(
+            event_generator(request, connection_id), media_type="text/event-stream"
+        )
+
+
+def when_server_reload():
+    for task_id, task in _task_events.items():
+        task.set()
+
+    _task_events.clear()

instaui/fastapi_server/dependency_router.py

@@ -0,0 +1,28 @@
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+
+from instaui.fastapi_server import resource
+
+
+URL = f"{resource.URL}/{{hash_part:path}}/{{file_name:path}}"
+
+
+def create_router(app: FastAPI):
+    _dependency_handler(app)
+
+
+def _dependency_handler(app: FastAPI):
+    @app.get(URL)
+    def _(hash_part: str, file_name: str) -> FileResponse:
+        hash_part_with_extend_paths = hash_part.split("/", maxsplit=1)
+        hash_part = hash_part_with_extend_paths[0]
+        extend_path = None if len(hash_part_with_extend_paths) == 1 else hash_part_with_extend_paths[1]
+
+        folder = resource.get_folder_path(hash_part)
+        if extend_path:
+            folder = folder.joinpath(extend_path)
+        local_file = folder / file_name
+
+        return FileResponse(
+            local_file, headers={"Cache-Control": "public, max-age=3600"}
+        )

instaui/fastapi_server/event_router.py

@@ -0,0 +1,58 @@
+import inspect
+from typing import Dict
+from fastapi import FastAPI
+
+from instaui.handlers import event_handler
+from instaui.runtime.context import get_context
+
+from . import _utils
+
+
+def create_router(app: FastAPI):
+    _async_handler(app)
+    _sync_handler(app)
+
+
+def _async_handler(app: FastAPI):
+    @app.post(event_handler.ASYNC_URL)
+    async def _(data: Dict):
+        handler = _get_handler(data)
+        if handler is None:
+            return {"error": "event handler not found"}
+
+        assert inspect.iscoroutinefunction(
+            handler.fn
+        ), "handler must be a coroutine function"
+
+        _utils.update_app_page_info(data)
+
+        result = await handler.fn(*handler.get_handler_args(_get_binds_from_data(data)))
+        return _utils.response_data(handler.outputs_binding_count, result)
+
+
+def _sync_handler(app: FastAPI):
+    @app.post(event_handler.SYNC_URL)
+    def _(data: Dict):
+        handler = _get_handler(data)
+        if handler is None:
+            return {"error": "event handler not found"}
+
+        _utils.update_app_page_info(data)
+
+        result = handler.fn(*handler.get_handler_args(_get_binds_from_data(data)))
+
+        return _utils.response_data(handler.outputs_binding_count, result)
+
+    if get_context().debug_mode:
+
+        @app.get("/instaui/event-infos", tags=["instaui-debug"])
+        def event_infos():
+            return event_handler.get_statistics_info()
+
+
+def _get_handler(data: Dict):
+    return event_handler.get_handler(data["hKey"])
+
+
+def _get_binds_from_data(data: Dict):
+    return [bind for bind in data.get("bind", [])]

instaui/fastapi_server/middlewares.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import Any, Callable
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+from instaui.runtime import new_app_slot, reset_app_slot
+from .request_context import set_current_request
+
+
+class RequestContextMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: Callable) -> Any:
+        set_current_request(request)
+        system_slot_token = new_app_slot("web")
+
+        try:
+            response = await call_next(request)
+        finally:
+            reset_app_slot(system_slot_token)
+
+        return response

instaui/fastapi_server/request_context.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+from typing import Optional
+from fastapi import Request
+from contextvars import ContextVar, Token
+
+current_request_ctx :ContextVar[Optional[Request]]= ContextVar("current_request", default=None)
+
+
+
+def set_current_request(request: Request) :
+    return current_request_ctx.set(request)
+
+def reset_current_request(token: Token) -> None:
+    current_request_ctx.reset(token)
+
+
+def get_current_request() -> Request:
+    return current_request_ctx.get()  # type: ignore
+

instaui/fastapi_server/resource.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+from typing import Dict
+from instaui.systems import file_system
+from instaui.version import __version__ as _INSTA_VERSION
+
+URL = f"/_instaui_{_INSTA_VERSION}/resource"
+_THashPart = str
+_HASH_PART_MAP: Dict[_THashPart, Path] = {}
+_PATH_URL_MAP: Dict[Path, _THashPart] = {}
+
+
+def get_folder_path(hash_part: str) -> Path:
+    return _HASH_PART_MAP[hash_part]
+
+
+def record_resource(path: Path):
+    path = Path(path).resolve()
+    is_file = path.is_file()
+
+    folder_path = path.parent if is_file else path
+
+    if folder_path not in _HASH_PART_MAP:
+        hash_part = file_system.generate_hash_name_from_path(folder_path)
+        _HASH_PART_MAP[hash_part] = folder_path
+    else:
+        hash_part = _PATH_URL_MAP[folder_path]
+
+    folder_url = f"{URL}/{hash_part}/"
+
+    return f"{folder_url}{path.name}" if is_file else folder_url