instaui 0.1.0__py3-none-any.whl

instaui/fastapi_server/debug_mode_router.py

@@ -0,0 +1,61 @@
+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: int = 2
+):
+    logger.debug("debug sse started")
+    task_event = asyncio.Event()
+    _task_events[connection_id] = task_event
+
+    # yield "event: task\ndata: 0 \n\n\n"
+    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/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/server.py

@@ -0,0 +1,246 @@
+from __future__ import annotations
+import inspect
+import os
+import multiprocessing
+from pathlib import Path
+from typing import Any, Optional, Set
+import __main__
+
+from fastapi import FastAPI
+from fastapi import Request
+from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+import uvicorn
+from uvicorn.supervisors import ChangeReload
+
+from instaui.html_tools import to_json
+from instaui.launch_collector import get_launch_collector
+from instaui.page_info import PageInfo
+from instaui.handlers import config_handler
+from instaui.systems import file_system
+from instaui import consts
+from instaui.runtime._app import get_app_slot
+from instaui.template import web_template
+from . import config_router
+from . import event_router
+from . import watch_router
+from . import debug_mode_router
+from .middlewares import RequestContextMiddleware
+from ._uvicorn import UvicornServer
+
+
+APP_IMPORT_STRING = "instaui.fastapi_server.server:Server._instance.app"
+
+
+class Server:
+    _instance: Optional[Server] = None
+
+    @classmethod
+    def get_instance(cls):
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    def __init__(self):
+        self.app = FastAPI()
+        self.app.add_middleware(RequestContextMiddleware)
+        config_router.create_router(self.app)
+        event_router.create_router(self.app)
+        watch_router.create_router(self.app)
+        debug_mode_router.create_router(self.app)
+
+        self._static_dir_url = _add_static_dir(self.app)
+
+        for page_info in get_launch_collector()._page_router.values():
+            self.register_page(page_info)
+
+        self._registered_static_routes: Set[str] = set()
+
+    def register_page(self, info: PageInfo):
+        is_async = inspect.iscoroutinefunction(info.func)
+
+        self._remove_route(info.path)
+
+        key = info.create_key()
+        config_handler.register_handler(key, info.func)
+        config_fetch_url = (
+            config_handler.ASYNC_URL if is_async else config_handler.SYNC_URL
+        )
+
+        @self.app.get(info.path)
+        def wrapper(request: Request):
+            page_loadding_json = None
+            if info.page_loading:
+                loadding_result = info.page_loading()
+                if loadding_result:
+                    return loadding_result
+                page_loadding_json = to_json()
+
+            html = self._to_web_html(
+                page_info=info,
+                config_fetch_url=config_fetch_url,
+                config_fetch_key=key,
+                query_path=info.path,
+                request=request,
+                page_loadding_json=page_loadding_json,
+            )
+            response = HTMLResponse(html)
+            return response
+
+        return wrapper
+
+    def _to_web_html(
+        self,
+        *,
+        page_info: PageInfo,
+        query_path: str,
+        config_json: Optional[str] = None,
+        config_fetch_url: Optional[str] = None,
+        config_fetch_key: Optional[str] = None,
+        page_loadding_json: Optional[str] = None,
+        request: Request,
+    ):
+        system_slot = get_app_slot()
+        html_resource = system_slot._html_resource
+        page_info.apply_settings(html_resource)
+
+        html_resource.add_import_map(
+            "vue", self._static_dir_url + f"/{consts.VUE_ES_JS_PATH.name}"
+        )
+
+        html_resource.add_import_map(
+            "instaui", self._static_dir_url + f"/{consts.APP_ES_JS_PATH.name}"
+        )
+        html_resource.add_css_link(consts.APP_CSS_PATH)
+
+        if html_resource.use_tailwind:
+            tailwind_url = self._static_dir_url + f"/{consts.TAILWIND_JS_PATH.name}"
+            html_resource.add_js_link(tailwind_url)
+
+        # register custom components
+        # TODO: use one get api to get all components
+        for component in system_slot._js_components:
+            if not component.esm:
+                continue
+            url = self.add_static_file_route(component.esm)
+            html_resource.add_vue_app_component(name=component.name, url=url)
+
+            if component.css:
+                for css_link in component.css:
+                    html_resource.add_css_link(css_link)
+
+        # register custom plugins
+        for plugin in system_slot._plugins:
+            if not plugin.esm:
+                continue
+            url = self.add_static_file_route(plugin.esm)
+            html_resource.add_vue_app_use(url)
+
+            if plugin.css:
+                for css_link in plugin.css:
+                    html_resource.add_css_link(css_link)
+
+        # css file link to web static link
+        html_resource._css_links = {
+            self.add_static_file_route(link) if isinstance(link, Path) else link: None
+            for link, attrs in html_resource._css_links.items()
+        }
+
+        # js file link to web static link
+        for info in html_resource._js_links:
+            if isinstance(info.link, Path):
+                info.link = self.add_static_file_route(info.link)
+
+        prefix = request.headers.get(
+            "X-Forwarded-Prefix", request.scope.get("root_path", "")
+        )
+
+        result = web_template.render_web_html(
+            config_json=config_json,
+            config_fetch_url=config_fetch_url,
+            config_fetch_key=config_fetch_key,
+            query_path_params=str(request.path_params),
+            query_params=dict(request.query_params),
+            query_path=query_path,
+            page_loadding_json=page_loadding_json,
+            prefix=prefix,
+        )
+        get_app_slot().reset_html_resource()
+        return result
+
+    def add_static_file_route(self, local_file: Path) -> str:
+        path = file_system.generate_static_url_from_file_path(local_file)
+        if path in self._registered_static_routes:
+            return path
+
+        @self.app.get(path)
+        def _() -> FileResponse:
+            return FileResponse(
+                local_file, headers={"Cache-Control": "public, max-age=3600"}
+            )
+
+        return path
+
+    def _remove_route(self, path: str) -> None:
+        self.app.routes[:] = [
+            r for r in self.app.routes if getattr(r, "path", None) != path
+        ]
+
+    def try_close_server(self):
+        UvicornServer.instance.should_exit = True
+
+    def run(
+        self,
+        host="0.0.0.0",
+        port=8080,
+        reload: bool = True,
+        reload_dirs: str = ".",
+        reload_includes: str = "*.py",
+        reload_excludes: str = ".*, .py[cod], .sw.*, ~*",
+        log_level="info",
+        workers: int | None = None,
+        uds: str | None = None,
+        **kwargs: Any,
+    ):
+        if multiprocessing.current_process().name != "MainProcess":
+            return
+
+        if reload and not hasattr(__main__, "__file__"):
+            reload = False
+
+        config = uvicorn.Config(
+            APP_IMPORT_STRING if reload else self.app,
+            host=host,
+            port=port,
+            reload=reload,
+            log_level=log_level,
+            workers=workers,
+            uds=uds,
+            reload_includes=_split_args(reload_includes) if reload else None,
+            reload_excludes=_split_args(reload_excludes) if reload else None,
+            reload_dirs=_split_args(reload_dirs) if reload else None,
+            **kwargs,
+        )
+
+        UvicornServer.create_singleton(config, [debug_mode_router.when_server_reload])
+
+        if config.should_reload:
+            ChangeReload(config, target=UvicornServer.instance.run, sockets=[]).run()
+        else:
+            UvicornServer.instance.run()
+
+        if config.uds:
+            os.remove(config.uds)  # pragma: py-win32
+
+    def run_with(self, app):
+        assert isinstance(app, FastAPI), "app must be a FastAPI instance"
+
+
+def _add_static_dir(app: FastAPI):
+    url = file_system.generate_static_url_from_file_path(consts._STATIC_DIR)
+    app.mount(url, StaticFiles(directory=consts._STATIC_DIR))
+    return url
+
+
+def _split_args(args: str):
+    return [a.strip() for a in args.split(",")]

instaui/fastapi_server/watch_router.py

@@ -0,0 +1,53 @@
+from typing import Dict
+from fastapi import FastAPI
+from instaui.handlers import watch_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(watch_handler.ASYNC_URL)
+    async def _(data: Dict):
+        hkey = data.pop("key")
+        handler_info = watch_handler.get_handler_info(hkey)
+        if handler_info is None:
+            return {"error": "watch handler not found"}
+
+        _utils.update_app_page_info(data)
+
+        result = await handler_info.fn(
+            *handler_info.get_handler_args(_get_binds_from_data(data))
+        )
+        return _utils.response_data(handler_info.outputs_binding_count, result)
+
+
+def _sync_handler(app: FastAPI):
+    @app.post(watch_handler.SYNC_URL)
+    def _(data: Dict):
+        hkey = data.pop("key")
+        handler_info = watch_handler.get_handler_info(hkey)
+        if handler_info is None:
+            return {"error": "watch handler not found"}
+
+        _utils.update_app_page_info(data)
+
+        result = handler_info.fn(
+            *handler_info.get_handler_args(_get_binds_from_data(data))
+        )
+        return _utils.response_data(handler_info.outputs_binding_count, result)
+
+    if get_context().debug_mode:
+
+        @app.get("/instaui/watch-infos", tags=["instaui-debug"])
+        def watch_infos():
+            return watch_handler.get_statistics_info()
+
+
+def _get_binds_from_data(data: Dict):
+    return data.get("input", [])

instaui/handlers/_utils.py

@@ -0,0 +1,66 @@
+from dataclasses import dataclass, field
+from typing import Callable, List, Mapping, Optional
+
+import pydantic_core
+from instaui.systems import func_system, pydantic_system
+from instaui.runtime.context import get_context
+
+
+def create_handler_key(
+    page_path: str,
+    handler: Callable,
+):
+    _, lineno, _ = func_system.get_function_location_info(handler)
+
+    if get_context().debug_mode:
+        return f"page:{page_path}|line:{lineno}"
+
+    return f"{page_path}|{lineno}"
+
+
+@dataclass
+class HandlerInfo:
+    fn: Callable
+    fn_location_info: str
+    outputs_binding_count: int = 0
+    hanlder_param_converters: List[pydantic_system.TypeAdapterProtocol] = field(
+        default_factory=list
+    )
+
+    def get_handler_args(self, input_values: List):
+        try:
+            return [
+                param_converter.to_python_value(value)
+                for param_converter, value in zip(
+                    self.hanlder_param_converters, input_values
+                )
+            ]
+        except pydantic_core._pydantic_core.ValidationError as e:
+            raise ValueError(f"invalid input[{self.fn_location_info}]: {e}") from None
+
+    @classmethod
+    def from_handler(
+        cls,
+        handler: Callable,
+        outputs_binding_count: int,
+        custom_type_adapter_map: Optional[
+            Mapping[int, pydantic_system.TypeAdapterProtocol]
+        ] = None,
+    ):
+        custom_type_adapter_map = custom_type_adapter_map or {}
+        params_infos = func_system.get_fn_params_infos(handler)
+        param_converters = [
+            custom_type_adapter_map.get(
+                idx, pydantic_system.create_type_adapter(param_type)
+            )
+            for idx, (_, param_type) in enumerate(params_infos)
+        ]
+
+        file, lineno, _ = func_system.get_function_location_info(handler)
+
+        return cls(
+            handler,
+            f'File "{file}", line {lineno}',
+            outputs_binding_count,
+            hanlder_param_converters=param_converters,
+        )

instaui/handlers/computed_handler.py

@@ -0,0 +1,42 @@
+import threading
+from typing import Callable, Dict, Optional
+
+from instaui.runtime.context import get_context
+from instaui.systems import func_system
+
+
+ASYNC_URL = "/instaui/computed/async"
+SYNC_URL = "/instaui/computed/sync"
+INIT_URL = "/instaui/computed/init"
+
+_computed_handlers: Dict[str, Callable] = {}
+dict_lock = threading.Lock()
+
+
+def register_handler(key: str, handler: Callable):
+    if key in _computed_handlers:
+        return
+    with dict_lock:
+        _computed_handlers[key] = handler
+
+
+def get_handler(key: str) -> Optional[Callable]:
+    return _computed_handlers.get(key)
+
+
+def get_statistics_info():
+    return {
+        "_computed_handlers count": len(_computed_handlers),
+        "_computed_handlers keys": list(_computed_handlers.keys()),
+    }
+
+
+def create_handler_key(
+    page_path: str,
+    handler: Callable,
+):
+    _, lineno, _ = func_system.get_function_location_info(handler)
+
+    if get_context().debug_mode:
+        return f"path:{page_path}|line:{lineno}"
+    return f"{page_path}|{lineno}"

instaui/handlers/config_handler.py

@@ -0,0 +1,13 @@
+from typing import Callable, Dict
+
+ASYNC_URL = "/instaui/config/async"
+SYNC_URL = "/instaui/config/sync"
+_handlers: Dict[str, Callable] = {}
+
+
+def register_handler(key: str, handler: Callable):
+    _handlers[key] = handler
+
+
+def get_handler(key: str) -> Callable:
+    return _handlers[key]

instaui/handlers/event_handler.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+import threading
+from typing import Callable, Dict, Optional, Sequence, TYPE_CHECKING
+from . import _utils
+import ast
+from instaui.vars.event_context import DatasetEventContext
+
+if TYPE_CHECKING:
+    from instaui.vars.mixin_types.py_binding import CanOutputMixin, CanInputMixin
+
+ASYNC_URL = "/instaui/event/async"
+SYNC_URL = "/instaui/event/sync"
+_event_handlers: Dict[str, _utils.HandlerInfo] = {}
+dict_lock = threading.Lock()
+
+
+class EventDataSetTypeAdapter:
+    def to_python_value(self, value, *args, **kwargs):
+        return ast.literal_eval(value)
+
+
+def register_event_handler(
+    key: str,
+    handler: Callable,
+    outputs_binding: Optional[Sequence[CanOutputMixin]],
+    inputs_binding: Optional[Sequence[CanInputMixin]],
+):
+    if key in _event_handlers:
+        return
+
+    custom_type_adapter_map = {
+        i: EventDataSetTypeAdapter()
+        for i, binding in enumerate(inputs_binding or [])
+        if isinstance(binding, DatasetEventContext)
+    }
+
+    handler_info = _utils.HandlerInfo.from_handler(
+        handler,
+        len(list(outputs_binding)) if outputs_binding else 0,
+        custom_type_adapter_map=custom_type_adapter_map,
+    )
+
+    with dict_lock:
+        _event_handlers[key] = handler_info
+
+
+def get_handler(key: str) -> Optional[_utils.HandlerInfo]:
+    return _event_handlers.get(key)
+
+
+def get_statistics_info():
+    return {
+        "_event_handlers count": len(_event_handlers),
+        "_event_handlers keys": list(_event_handlers.keys()),
+    }
+
+
+create_handler_key = _utils.create_handler_key

instaui/handlers/watch_handler.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+import threading
+from typing import (
+    Callable,
+    Dict,
+    Generic,
+    TypeVar,
+)
+from dataclasses import dataclass
+
+from instaui.runtime.context import get_context
+from instaui.systems import func_system
+from . import _utils
+
+
+ASYNC_URL = "/instaui/watch/async"
+SYNC_URL = "/instaui/watch/sync"
+_watch_handlers: Dict[str, _utils.HandlerInfo] = {}
+dict_lock = threading.Lock()
+
+
+def register_handler(key: str, handler: Callable, outputs_binding_count: int):
+    if key in _watch_handlers:
+        return
+    with dict_lock:
+        _watch_handlers[key] = _utils.HandlerInfo.from_handler(
+            handler, outputs_binding_count
+        )
+
+
+def get_handler_info(key: str) -> _utils.HandlerInfo:
+    return _watch_handlers.get(key)  # type: ignore
+
+
+def get_statistics_info():
+    return {
+        "_watch_handlers count": len(_watch_handlers),
+        "_watch_handlers keys": list(_watch_handlers.keys()),
+    }
+
+
+def create_handler_key(page_path: str, handler: Callable):
+    _, lineno, _ = func_system.get_function_location_info(handler)
+
+    if get_context().debug_mode:
+        return f"path:{page_path}|line:{lineno}"
+    return f"{page_path}|{lineno}"
+
+
+_TWatchStateValue = TypeVar("_TWatchStateValue")
+
+
+@dataclass(frozen=True)
+class WatchState(Generic[_TWatchStateValue]):
+    new_value: _TWatchStateValue
+    old_value: _TWatchStateValue
+    modified: bool