instaui 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

instaui/template/_utils.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+import typing
+from pathlib import Path
+from urllib.parse import quote
+import base64
+
+
+_JS_PREFIX = "data:text/javascript;charset=utf-8"
+_CSS_PREFIX = "data:text/css;charset=utf-8"
+_ICON_PREFIX = "data:image/x-icon;base64"
+
+
+def normalize_path_to_dataurl(path: typing.Union[str, Path], prefix: str):
+    if isinstance(path, Path):
+        path = path.read_text(encoding="utf-8")
+
+    return f"{prefix},{quote(path)}"
+
+
+def normalize_path_to_base64_url(path: typing.Optional[Path], prefix: str):
+    if path is None:
+        return None
+    return f"{prefix},{base64.b64encode(path.read_bytes()).decode('utf-8')}"

instaui/template/webview_template.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+import typing
+from pathlib import Path
+from dataclasses import dataclass, field
+from instaui.common.jsonable import dumps
+from instaui.runtime.dataclass import JsLink
+from .env import env
+
+
+_html_template = env.get_template("webview.html")
+
+
+@dataclass(frozen=True)
+class WebViewVueAppComponent:
+    name: str
+    url: str
+
+
+@dataclass
+class WebViewTemplateModel:
+    vue_js_code: str
+    instaui_js_code: str
+    config_dict: typing.Dict[str, typing.Any] = field(default_factory=dict)
+    extra_import_maps: typing.Dict[str, str] = field(default_factory=dict)
+    css_links: typing.List[str] = field(default_factory=list)
+    style_tags: typing.List[str] = field(default_factory=list)
+    js_links: typing.List[str] = field(default_factory=list)
+    script_tags: typing.List[str] = field(default_factory=list)
+    vue_app_use: typing.List[str] = field(default_factory=list)
+    vue_app_component: typing.List[WebViewVueAppComponent] = field(default_factory=list)
+    title: typing.Optional[str] = None
+    favicon_url: typing.Optional[str] = None
+    on_app_mounted: typing.Optional[typing.Callable] = None
+
+    def add_extra_import_map(self, name: str, code: str):
+        self.extra_import_maps[name] = code
+
+    @property
+    def import_maps_string(self):
+        data = {
+            **self.extra_import_maps,
+            "vue": self.vue_js_code,
+            "instaui": self.instaui_js_code,
+        }
+
+        return dumps(data)
+
+
+def render_wbeview_html(model: WebViewTemplateModel) -> str:
+    return _html_template.render(model=model)

instaui/ui/__init__.py

@@ -61,8 +61,11 @@ __all__ = [
     "str_format",
     "url_location",
     "on_page_request_lifespan",
+    "webview",
     "code",
     "markdown",
+    "echarts",
+    "use_shadcn_classless",
 ]
 
 # -- static imports
@@ -126,5 +129,8 @@ from .events import on_page_request_lifespan
 
 # -- dynamic imports
 from instaui.systems.module_system import LazyModule
-code = LazyModule('instaui.components.highlight_code.code', 'Code')
-markdown = LazyModule('instaui.components.markdown.markdown', 'Markdown')
+code = LazyModule('instaui.components.shiki_code.shiki_code', 'Code')
+markdown = LazyModule('instaui.components.markdown.markdown', 'Markdown')
+webview = LazyModule('instaui.webview', 'WebviewWrapper')
+echarts = LazyModule('instaui.components.echarts.echarts', 'ECharts')
+use_shadcn_classless = LazyModule('instaui.shadcn_classless._index', 'use_shadcn_classless')

instaui/ui/__init__.pyi

@@ -61,8 +61,11 @@ __all__ = [
     "str_format",
     "url_location",
     "on_page_request_lifespan",
+    "webview",
     "code",
     "markdown",
+    "echarts",
+    "use_shadcn_classless",
 ]
 
 # -- static imports
@@ -125,5 +128,8 @@ from instaui.ui_functions.ui_types import TBindable, is_bindable
 from .events import on_page_request_lifespan
 
 # -- dynamic imports
-from instaui.components.highlight_code.code import Code as code
+from instaui.components.shiki_code.shiki_code import Code as code
 from instaui.components.markdown.markdown import Markdown as markdown
+from instaui.webview import WebviewWrapper as webview
+from instaui.components.echarts.echarts import ECharts as echarts
+from instaui.shadcn_classless._index import use_shadcn_classless

instaui/vars/event_context.py

@@ -30,6 +30,10 @@ class EventContext(Jsonable, CanInputMixin):
     def e():
         return EventContext(":e => e")
 
+    @staticmethod
+    def target_value():
+        return EventContext(":e => e.target.value")
+
 
 class DatasetEventContext(Jsonable, CanInputMixin):
     def __init__(self, event_context: EventContext) -> None:

instaui/vars/web_computed.py

@@ -24,6 +24,9 @@ from instaui.vars.mixin_types.observable import ObservableMixin
 from instaui.vars.mixin_types.common_type import TObservableInput
 from instaui._helper import observable_helper
 
+_SYNC_TYPE = "sync"
+_ASYNC_TYPE = "async"
+
 P = ParamSpec("P")
 R = TypeVar("R")
 
@@ -70,47 +73,44 @@ class WebComputed(
 
         app = get_app_slot()
 
-        if app.mode == "web":
-            hkey = watch_handler.create_handler_key(
-                page_path=app.page_path,
-                handler=self._fn,
-            )
+        hkey = watch_handler.create_handler_key(
+            page_path=app.page_path,
+            handler=self._fn,
+        )
 
-            watch_handler.register_handler(hkey, self._fn, len(self._outputs) + 1)
+        watch_handler.register_handler(hkey, self._fn, len(self._outputs) + 1)
 
-            url = (
-                watch_handler.ASYNC_URL
-                if inspect.iscoroutinefunction(self._fn)
-                else watch_handler.SYNC_URL
-            )
+        # if app.mode == "web":
 
-            data["id"] = self._id
-            data["sid"] = self._sid
-            data["type"] = self.VAR_TYPE
+        data["id"] = self._id
+        data["sid"] = self._sid
+        data["type"] = self.VAR_TYPE
 
-            if self._inputs:
-                data["inputs"] = self._inputs
+        if self._inputs:
+            data["inputs"] = self._inputs
 
-            if self._outputs:
-                data["outputs"] = self._outputs
+        if self._outputs:
+            data["outputs"] = self._outputs
 
-            if sum(self._is_slient_inputs) > 0:
-                data["slient"] = self._is_slient_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 sum(self._is_data) > 0:
+            data["data"] = self._is_data
 
-            data["url"] = url
-            data["key"] = hkey
-            if self._init_value is not None:
-                data["init"] = self._init_value
+        data["fType"] = (
+            _ASYNC_TYPE if inspect.iscoroutinefunction(self._fn) else _SYNC_TYPE
+        )
+        data["key"] = hkey
+        if self._init_value is not None:
+            data["init"] = self._init_value
 
-            if self._evaluating:
-                data["running"] = self._evaluating._to_output_config()
+        if self._evaluating:
+            data["running"] = self._evaluating._to_output_config()
 
-            return data
+        return data
 
-        return {}
+        # return {}
 
     def __to_binding_config(self):
         return {

instaui/watch/web_watch.py

@@ -13,6 +13,9 @@ from instaui.vars.mixin_types.py_binding import CanOutputMixin
 from instaui.vars.mixin_types.common_type import TObservableInput
 from instaui._helper import observable_helper
 
+_SYNC_TYPE = "sync"
+_ASYNC_TYPE = "async"
+
 P = ParamSpec("P")
 R = typing.TypeVar("R")
 
@@ -59,13 +62,9 @@ class WebWatch(Jsonable, typing.Generic[P, R]):
 
             watch_handler.register_handler(hkey, self._fn, len(self._outputs))
 
-            url = (
-                watch_handler.ASYNC_URL
-                if inspect.iscoroutinefunction(self._fn)
-                else watch_handler.SYNC_URL
+            data["fType"] = (
+                _ASYNC_TYPE if inspect.iscoroutinefunction(self._fn) else _SYNC_TYPE
             )
-
-            data["url"] = url
             data["key"] = hkey
             if self._inputs:
                 data["inputs"] = self._inputs

instaui/webview/__init__.py

@@ -0,0 +1 @@
+from .index import WebviewWrapper

instaui/webview/_utils.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+import shutil
+
+
+def reset_dir(dir_path: Path):
+    if dir_path.exists():
+        shutil.rmtree(dir_path)
+    dir_path.mkdir(exist_ok=True)

instaui/webview/api.py

@@ -0,0 +1,72 @@
+from typing import Any, Dict
+
+
+from instaui.runtime._app import get_app_slot
+from instaui.handlers import watch_handler
+from instaui.handlers import event_handler
+from instaui.skip import is_skip_output
+
+
+class Api:
+    def watch_call(self, 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"}
+
+        update_app_page_info(data)
+
+        result = handler_info.fn(
+            *handler_info.get_handler_args(_get_binds_from_data(data))
+        )
+        return response_data(handler_info.outputs_binding_count, result)
+
+    def event_call(self, data: Dict):
+        handler = event_handler.get_handler(data["hKey"])
+        if handler is None:
+            raise ValueError("event handler not found")
+
+        update_app_page_info(data)
+
+
+        args = [bind for bind in data.get("bind", [])]
+
+        result = handler.fn(*handler.get_handler_args(args))
+        return response_data(handler.outputs_binding_count, result)
+
+
+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 _get_binds_from_data(data: Dict):
+    return data.get("input", [])
+
+
+def response_data(outputs_binding_count: int, result: Any):
+    data = {}
+    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/webview/func.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+import itertools
+from pathlib import Path
+import instaui.consts as consts
+from instaui.runtime._app import get_app_slot, get_default_app_slot
+from instaui.template import render_zero_html
+from instaui.template import zero_template
+from instaui.html_tools import to_config_data
+from instaui.runtime.dataclass import JsLink
+from instaui.runtime.resource import HtmlResource
+
+
+def get_template_model():
+    system_slot = get_app_slot()
+
+    merge_global_resources = (system_slot.meta or {}).get(
+        "merge_global_resources", True
+    )
+
+    default_app_slot = get_default_app_slot()
+    html_resource = system_slot._html_resource
+    default_html_resource = (
+        default_app_slot._html_resource
+        if merge_global_resources
+        else _empty_html_resource()
+    )
+
+    config_data = to_config_data()
+
+    model = zero_template.ZeroTemplateModel(
+        vue_js_code=consts.VUE_ES_JS_PATH,
+        instaui_js_code=consts.APP_ES_JS_PATH,
+        css_links=[
+            consts.APP_CSS_PATH,
+        ],
+        config_dict=config_data,
+        favicon=html_resource.favicon
+        or default_html_resource.favicon
+        or consts.FAVICON_PATH,
+        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(
+            zero_template.ZeroVueAppComponent(
+                name=component.tag_name,
+                url=component.esm,
+            )
+        )
+
+        if component.css:
+            for css_link in component.css:
+                model.css_links.append(css_link)
+
+        if component.externals:
+            for name, url in component.externals.items():
+                if url.is_file():
+                    model.add_extra_import_map(name, 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, plugin.esm)
+
+        if plugin.css:
+            for css_link in plugin.css:
+                model.css_links.append(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(link)
+
+    # js file link to web static link
+    for info in html_resource.get_valid_js_links(
+        default_html_resource._js_links_manager
+    ):
+        if isinstance(info.link, Path):
+            model.js_links.append(JsLink(info.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)
+
+    return model
+
+
+def to_html_str():
+    model = get_template_model()
+    return render_zero_html(model)
+
+
+def _empty_html_resource():
+    return HtmlResource()

instaui/webview/index.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+from contextlib import contextmanager
+from pathlib import Path
+import shutil
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
+from typing_extensions import TypedDict, Unpack
+import webview
+import webview.http as http
+from webview.guilib import GUIType
+
+from instaui.runtime._app import get_app_slot, new_app_slot, reset_app_slot
+from instaui.launch_collector import get_launch_collector
+
+from . import resource
+from . import api
+from . import _utils
+
+
+class WebviewWrapper:
+    """Example usage:
+    .. code-block:: python
+        from instaui import ui
+
+        @ui.page("/")
+        def index_page():
+            ui.content("Hello, world!")
+
+        ui.webview().run()
+    """
+
+    def __init__(
+        self,
+        *,
+        assets_path: Union[str, Path] = "./webview_assets",
+        debug: bool = False,
+        auto_create_window: Union[bool, str] = "/",
+        on_app_mounted: Optional[Callable] = None,
+    ) -> None:
+        """Create a new webview wrapper.
+
+        Args:
+            assets_path (Union[str, Path], optional): Path to store assets. Defaults to "./webview_assets".
+            debug (bool, optional): Whether to run in debug mode. Defaults to False.
+            auto_create_window (Union[bool, str], optional): Whether to create a window automatically. If a string is provided, it will be used as the initial page URL. Defaults to "/".
+            testing (bool, optional): Whether to run in testing mode. Defaults to False.
+        """
+
+        self.assets_path = (
+            Path(self._get_assets_path(assets_path))
+            if isinstance(assets_path, str)
+            else assets_path
+        )
+        _utils.reset_dir(self.assets_path)
+        self.debug = debug
+        self.on_app_mounted = on_app_mounted
+
+        self._auto_create_window = auto_create_window
+
+    def create_window(
+        self,
+        page_url: str = "/",
+    ):
+        """Create a new window. Returns the window object of pywebview.
+
+        Args:
+            page_url (str, optional): Page URL to load. Defaults to "/".
+
+        """
+        launch_collector = get_launch_collector()
+        with _scope():
+            app = get_app_slot()
+            app._page_path = page_url
+            page_info = launch_collector._page_router[page_url]
+            page_info.func()
+
+            resource_info = resource.resource_to_assets(
+                page_url=page_url,
+                assets_path=self.assets_path,
+                on_app_mounted=self.on_app_mounted,
+            )
+
+        window = webview.create_window(
+            resource_info.title, resource_info.index_html_url, js_api=api.Api()
+        )
+
+        if self.on_app_mounted:
+
+            def on_app_mounted():
+                self.on_app_mounted(window)  # type: ignore
+
+            window.expose(on_app_mounted)
+
+        return window
+
+    def run(self, **webview_start_args: Unpack[WebviewStartArgs]):
+        """Run the webview.
+
+        Args:
+            :param func: Function to invoke upon starting the GUI loop.
+            :param args: Function arguments. Can be either a single value or a tuple of
+                values.
+            :param localization: A dictionary with localized strings. Default strings
+                and their keys are defined in localization.py.
+            :param gui: Force a specific GUI. Allowed values are ``cef``, ``qt``,
+                ``gtk``, ``mshtml`` or ``edgechromium`` depending on a platform.
+            :param http_server: Enable built-in HTTP server. If enabled, local files
+                will be served using a local HTTP server on a random port. For each
+                window, a separate HTTP server is spawned. This option is ignored for
+                non-local URLs.
+            :param user_agent: Change user agent string.
+            :param private_mode: Enable private mode. In private mode, cookies and local storage are not preserved.
+                Default is True.
+            :param storage_path: Custom location for cookies and other website data
+            :param menu: List of menus to be included in the app menu
+            :param server: Server class. Defaults to BottleServer
+            :param server_args: Dictionary of arguments to pass through to the server instantiation
+            :param ssl: Enable SSL for local HTTP server. Default is False.
+            :param icon: Path to the icon file. Supported only on GTK/QT.
+        """
+
+        if self._auto_create_window:
+            self.create_window(
+                "/" if self._auto_create_window is True else self._auto_create_window
+            )
+
+        webview.start(**webview_start_args, debug=self.debug)
+
+    @staticmethod
+    def _get_assets_path(file: Union[str, Path]) -> Path:
+        if isinstance(file, str):
+            import inspect
+
+            frame = inspect.currentframe().f_back.f_back.f_back  # type: ignore
+            assert frame is not None
+            script_file = inspect.getfile(frame)
+            file = Path(script_file).parent.joinpath(file)
+
+        return file
+
+
+@contextmanager
+def _scope():
+    token = new_app_slot("webview")
+    yield
+    reset_app_slot(token)
+
+
+class WebviewStartArgs(TypedDict, total=False):
+    func: Union[Callable[..., None], None]
+    args: Union[Iterable[Any], None]
+    localization: Dict[str, str]
+    gui: Union[GUIType, None]
+    http_server: bool
+    http_port: Union[int, None]
+    user_agent: Union[str, None]
+    private_mode: bool
+    storage_path: Union[str, None]
+    menu: List[Any]
+    server: type[http.ServerType]  # type: ignore
+    server_args: Dict[Any, Any]
+    ssl: bool
+    icon: Union[str, None]