instaui 0.1.15__py2.py3-none-any.whl

instaui/fastapi_server/server.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+from contextlib import contextmanager
+import inspect
+import os
+import multiprocessing
+from pathlib import Path
+from typing import Any, Optional, Set, Union
+import __main__
+
+from fastapi import FastAPI
+from fastapi import Request
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import HTMLResponse
+import uvicorn
+from uvicorn.supervisors import ChangeReload
+import itertools
+
+from instaui.html_tools import to_config_data
+from instaui.launch_collector import get_launch_collector
+from instaui.page_info import PageInfo
+
+from instaui import consts
+from instaui.runtime._app import get_app_slot, get_default_app_slot
+from instaui.runtime.dataclass import JsLink, VueAppComponent
+from instaui.template import web_template
+
+
+from . import dependency_router
+from . import event_router
+from . import watch_router
+from . import debug_mode_router
+from .middlewares import RequestContextMiddleware
+from ._uvicorn import UvicornServer
+from . import resource
+from instaui.version import __version__ as _INSTA_VERSION
+
+APP_IMPORT_STRING = "instaui.fastapi_server.server:Server._instance.app"
+
+
+INSTAUI_STATIC_URL = f"/_instaui_{_INSTA_VERSION}/static"
+
+VUE_JS_HASH_LINK = f"{INSTAUI_STATIC_URL}/{consts.VUE_ES_JS_PATH.name}"
+INSTAUI_JS_HASH_LINK = f"{INSTAUI_STATIC_URL}/{consts.APP_ES_JS_PATH.name}"
+APP_CSS_LINK = f"{INSTAUI_STATIC_URL}/{consts.APP_CSS_PATH.name}"
+FAVICON_LINK = f"{INSTAUI_STATIC_URL}/{consts.FAVICON_PATH.name}"
+
+
+class Server:
+    _instance: Optional[Server] = None
+
+    def __init__(
+        self,
+        use_gzip: Union[int, bool] = True,
+    ):
+        self.app = FastAPI()
+        self.app.add_middleware(RequestContextMiddleware)
+
+        if use_gzip:
+            self.app.add_middleware(
+                GZipMiddleware,
+                minimum_size=use_gzip if isinstance(use_gzip, int) else 500,
+            )
+
+        dependency_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.add_instaui_static(self.app)
+
+        for page_info in get_launch_collector()._page_router.values():
+            self.register_page(page_info)
+
+        self._registered_static_routes: Set[str] = set()
+
+        Server._instance = self
+
+    def register_page(self, info: PageInfo):
+        is_async = inspect.iscoroutinefunction(info.func)
+
+        self._remove_route(info.path)
+
+        if is_async:
+
+            @self.app.get(info.path)
+            async def _(request: Request):
+                self._update_page_info(request, info)
+                with _execute_request_lifespans():
+                    await info.func()
+                html = self._to_web_html(
+                    page_info=info,
+                    request=request,
+                )
+
+                return HTMLResponse(html)
+
+        else:
+
+            @self.app.get(info.path)
+            def _(request: Request):
+                self._update_page_info(request, info)
+                with _execute_request_lifespans():
+                    info.func()
+                html = self._to_web_html(
+                    page_info=info,
+                    request=request,
+                )
+
+                return HTMLResponse(html)
+
+    def _to_web_html(
+        self,
+        *,
+        page_info: PageInfo,
+        request: Request,
+    ):
+        config_data = to_config_data()
+
+        system_slot = get_app_slot()
+        default_app_slot = get_default_app_slot()
+        html_resource = system_slot._html_resource
+        default_html_resource = default_app_slot._html_resource
+
+        favicon_url = FAVICON_LINK
+        if html_resource.favicon:
+            favicon_url = resource.record_resource(html_resource.favicon)
+        else:
+            if default_html_resource.favicon:
+                favicon_url = resource.record_resource(default_html_resource.favicon)
+
+        model = web_template.WebTemplateModel(
+            vue_js_link=VUE_JS_HASH_LINK,
+            instaui_js_link=INSTAUI_JS_HASH_LINK,
+            css_links=[
+                APP_CSS_LINK,
+            ],
+            config_dict=config_data,
+            favicon_url=favicon_url,
+            title=html_resource.title
+            or default_html_resource.title
+            or consts.PAGE_TITLE,
+        )
+
+        # register custom components
+        for component in system_slot._component_dependencies:
+            if not component.esm:
+                continue
+
+            model.vue_app_component.append(
+                VueAppComponent(
+                    name=component.tag_name,
+                    url=resource.record_resource(component.esm),
+                )
+            )
+
+            if component.css:
+                for css_link in component.css:
+                    css_resource = resource.record_resource(css_link)
+                    if css_link.is_file():
+                        model.css_links.append(css_resource)
+
+            if component.externals:
+                for name, url in component.externals.items():
+                    model.add_extra_import_map(name, resource.record_resource(url))
+
+        # register custom plugins
+        for plugin in set(
+            itertools.chain(
+                system_slot._plugin_dependencies, default_app_slot._plugin_dependencies
+            )
+        ):
+            if not plugin.esm:
+                continue
+
+            model.vue_app_use.append(plugin.name)
+
+            model.add_extra_import_map(
+                plugin.name, resource.record_resource(plugin.esm)
+            )
+
+            if plugin.css:
+                for css_link in plugin.css:
+                    model.css_links.append(resource.record_resource(css_link))
+
+        # css file link to web static link
+        for link in html_resource.get_valid_css_links(
+            default_html_resource._css_links_manager
+        ):
+            if isinstance(link, Path):
+                model.css_links.append(resource.record_resource(link))
+            else:
+                model.css_links.append(link)
+
+        # js file link to web static link
+        for info in html_resource.get_valid_js_links(
+            default_html_resource._js_links_manager
+        ):
+            link = (
+                resource.record_resource(info.link)
+                if isinstance(info.link, Path)
+                else info.link
+            )
+            model.js_links.append(JsLink(link))
+
+        for js_code in itertools.chain(
+            html_resource._script_tags, default_html_resource._script_tags
+        ):
+            model.script_tags.append(js_code)
+
+        for sylte_code in itertools.chain(
+            html_resource._style_tags, default_html_resource._style_tags
+        ):
+            model.style_tags.append(sylte_code)
+
+        model.prefix = request.headers.get(
+            "X-Forwarded-Prefix", request.scope.get("root_path", "")
+        )
+
+        return web_template.render_web_html(model)
+
+    def _update_page_info(self, request: Request, page_info: PageInfo):
+        app = get_app_slot()
+
+        app._page_path = page_info.path
+        app._page_params = request.path_params
+        app._query_params = dict(request.query_params)
+
+    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"
+
+    @staticmethod
+    def add_instaui_static(app: FastAPI):
+        app.mount(
+            INSTAUI_STATIC_URL,
+            StaticFiles(directory=consts._STATIC_DIR),
+            name=INSTAUI_STATIC_URL,
+        )
+
+
+def _split_args(args: str):
+    return [a.strip() for a in args.split(",")]
+
+
+@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

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,88 @@
+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
+    handler_param_converters: List[pydantic_system.TypeAdapterProtocol] = field(
+        default_factory=list
+    )
+    is_last_param_args: bool = False
+
+    def get_handler_args(self, input_values: List):
+        real_param_converters = _try_expand_params_converters(
+            self.handler_param_converters, input_values, self.is_last_param_args
+        )
+
+        try:
+            return [
+                param_converter.to_python_value(value)
+                for param_converter, value in zip(real_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)
+        is_last_param_args = func_system.is_last_param_args(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,
+            handler_param_converters=param_converters,
+            is_last_param_args=is_last_param_args,
+        )
+
+
+def _try_expand_params_converters(
+    old_param_converters: List[pydantic_system.TypeAdapterProtocol],
+    input_values: List,
+    is_last_param_args: bool,
+):
+    if not is_last_param_args:
+        return old_param_converters
+
+    diff = len(input_values) - len(old_param_converters)
+    if diff == 0:
+        return old_param_converters
+
+    arg_param_converters = [old_param_converters[-1]] * diff
+
+    return [*old_param_converters[:], *arg_param_converters]

instaui/handlers/event_handler.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+import threading
+from typing import Callable, Dict, Optional, Sequence, TYPE_CHECKING
+import ast
+from . import _utils
+from instaui.vars.event_context import DatasetEventContext
+from instaui.runtime._app import update_web_server_info
+
+if TYPE_CHECKING:
+    from instaui.vars.mixin_types.py_binding import CanOutputMixin, CanInputMixin
+
+ASYNC_URL = "/instaui/event/async"
+SYNC_URL = "/instaui/event/sync"
+update_web_server_info(event_url=SYNC_URL, event_async_url=ASYNC_URL)
+_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,61 @@
+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.runtime._app import update_web_server_info
+from instaui.systems import func_system
+from . import _utils
+
+
+ASYNC_URL = "/instaui/watch/async"
+SYNC_URL = "/instaui/watch/sync"
+
+update_web_server_info(watch_url=SYNC_URL, watch_async_url=ASYNC_URL)
+
+_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

instaui/html_tools.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Any, Dict, Literal, Optional, Union
+from instaui.common.jsonable import dumps, dumps2dict
+from instaui.runtime._app import get_app_slot
+from instaui.tailwind._index import use_tailwind
+
+use_tailwind = use_tailwind
+
+
+def add_css_link(href: Union[str, Path]):
+    """Add a link to a CSS file to the HTML document.
+
+    Args:
+        href (Union[str, Path]): The path to the CSS file.
+    """
+    get_app_slot()._html_resource.add_css_link(href)
+
+
+def remove_css_link(href: Union[str, Path]):
+    """Remove a link to a CSS file from the HTML document.
+
+    Args:
+        href (Union[str, Path]): The path to the CSS file.
+    """
+    get_app_slot()._html_resource.remove_css_link(href)
+
+
+def add_js_link(
+    link: Union[str, Path],
+    *,
+    type: Optional[Literal["module"]] = None,
+):
+    """Add a link to a JavaScript file to the HTML document.
+
+    Args:
+        link (Union[str, Path]): The path to the JavaScript file.
+        type (Optional[Literal["module"]], optional): The type of the JavaScript file. Defaults to None.
+    """
+
+    attrs = {
+        "type": type,
+    }
+
+    get_app_slot()._html_resource.add_js_link(link, attrs=attrs)
+
+
+def add_style(content: str):
+    """Add a style tag to the HTML document.
+
+    Args:
+        content (str): The content of the style tag.
+    """
+    get_app_slot()._html_resource.add_style_tag(content)
+
+
+def use_page_title(title: str):
+    """Set the title of the HTML document.
+
+    Args:
+        title (str): The title of the HTML document.
+    """
+    get_app_slot()._html_resource.title = title
+
+
+def use_favicon(favicon: Path):
+    """Set the favicon of the HTML document.
+
+    Args:
+        favicon (Path): The path to the favicon.
+    """
+    get_app_slot()._html_resource.favicon = favicon
+
+
+def add_js_code(code: str, *, script_attrs: Optional[Dict[str, Any]] = None):
+    """Add a script tag to the HTML document with the given JavaScript code.
+
+    Args:
+        code (str): The JavaScript code.
+        script_attrs (Optional[Dict[str, Any]], optional): The attributes of the script tag. Defaults to None.
+    """
+    get_app_slot()._html_resource.add_script_tag(code, script_attrs=script_attrs)
+
+
+def add_vue_app_use(name: str):
+    get_app_slot()._html_resource.add_vue_app_use(name)
+
+
+def to_config_data() -> Dict:
+    return dumps2dict(get_app_slot())
+
+
+def to_json(indent=False):
+    return dumps(get_app_slot(), indent=indent)

instaui/inject.py

@@ -0,0 +1,33 @@
+import typing
+from instaui.runtime import ui_state_scope
+
+
+_T = typing.TypeVar("_T")
+
+
+def injection_key(key: str) -> _T:
+    """creates a key for injection
+
+    Args:
+        key (str): key to use for injection
+
+    Examples:
+    .. code-block:: python
+        text_key :str = injection_key("text")
+
+        # state model
+        class Person(ui.StateModel):
+            name:str
+
+        person_key :Person = injection_key(Person(name='foo'))
+    """
+    return key  # type: ignore
+
+
+def inject_state(key: _T) -> _T:
+    return typing.cast(_T, ui_state_scope.load_state(key))  # type: ignore
+
+
+def provide_state(key: _T, obj: _T) -> _T:
+    ui_state_scope.save_state(key, obj)
+    return obj

instaui/js/__init__.py

@@ -0,0 +1,4 @@
+from .lambda_func import LambdaFunc as func
+
+
+__all__ = ["func"]