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

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]

instaui/webview/resource.py

@@ -0,0 +1,172 @@
+from dataclasses import dataclass
+import itertools
+from pathlib import Path
+import shutil
+from typing import Callable, Optional
+from urllib.parse import quote
+
+from instaui.html_tools import to_config_data
+from instaui.runtime._app import get_app_slot, get_default_app_slot
+from instaui.systems import file_system
+from instaui.template import webview_template
+from instaui import consts
+
+from . import _utils
+
+
+_INDEX_HTML_NAME = "index.html"
+
+
+@dataclass
+class ResourceInfo:
+    title: str
+    index_html_url: str
+
+
+def resource_to_assets(
+    page_url: str, assets_path: Path, on_app_mounted: Optional[Callable] = None
+):
+    page_dir = assets_path.joinpath(quote(page_url, safe=""))
+    _utils.reset_dir(page_dir)
+
+    relative_to_assets = _get_relative_to_assets(page_dir)
+    file_to_assets = _get_file_to_assets(page_dir)
+
+    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
+
+    if html_resource.favicon:
+        favicon_url = file_to_assets(html_resource.favicon)
+    else:
+        if default_html_resource.favicon:
+            favicon_url = file_to_assets(default_html_resource.favicon)
+        else:
+            favicon_url = file_to_assets(consts.FAVICON_PATH)
+
+    model = webview_template.WebViewTemplateModel(
+        vue_js_code=file_to_assets(consts.VUE_ES_JS_PATH),
+        instaui_js_code=file_to_assets(consts.APP_ES_JS_PATH),
+        css_links=[
+            file_to_assets(consts.APP_CSS_PATH),
+        ],
+        config_dict=config_data,
+        favicon_url=favicon_url,
+        title=html_resource.title or default_html_resource.title or consts.PAGE_TITLE,
+        on_app_mounted=on_app_mounted,
+    )
+
+    # register custom components
+    for component in system_slot._component_dependencies:
+        if not component.esm:
+            continue
+
+        component_url = file_to_assets(component.esm)
+        model.add_extra_import_map(component_url, file_to_assets(component.esm))
+
+        model.vue_app_component.append(
+            webview_template.WebViewVueAppComponent(
+                name=component.tag_name,
+                url=component_url,
+            )
+        )
+
+        if component.css:
+            for css_link in component.css:
+                css_resource = file_to_assets(css_link)
+                if css_link.is_file():
+                    model.css_links.append(css_resource)
+
+        if component.externals:
+            for name, file in component.externals.items():
+                model.add_extra_import_map(name, file_to_assets(file))
+
+    # 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, file_to_assets(plugin.esm))
+
+        if plugin.css:
+            for css_link in plugin.css:
+                model.css_links.append(file_to_assets(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(file_to_assets(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 = file_to_assets(info.link) if isinstance(info.link, Path) else info.link
+        model.js_links.append(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)
+
+    html_str = webview_template.render_wbeview_html(model)
+
+    index_html_path = page_dir / _INDEX_HTML_NAME
+    index_html_path.write_text(html_str, encoding="utf-8")
+    relative_to_assets(index_html_path)
+    index_html_url = str(index_html_path.absolute())
+    return ResourceInfo(
+        title="test",
+        index_html_url=index_html_url,
+    )
+
+
+def _get_relative_to_assets(assets_path: Path):
+    def wrapper(file_path: Path, relative_parent=False):
+        return str(
+            file_path.relative_to(
+                assets_path.parent if relative_parent else assets_path
+            )
+        ).replace("\\", "/")
+
+    return wrapper
+
+
+def _get_file_to_assets(assets_path: Path):
+    relative_to_assets = _get_relative_to_assets(assets_path)
+
+    def wrapper(file_path: Path):
+        hash_part = file_system.generate_hash_name_from_path(file_path.parent)
+        new_folder_path = assets_path.joinpath(hash_part)
+
+        if not new_folder_path.exists():
+            new_folder_path.mkdir(parents=True)
+
+        new_path = new_folder_path.joinpath(file_path.name)
+
+        if file_path.is_file():
+            shutil.copyfile(file_path, new_path)
+            return "./" + relative_to_assets(new_path)
+        else:
+            shutil.copytree(file_path, new_path, dirs_exist_ok=True)
+            return "./" + relative_to_assets(new_path) + "/"
+
+    return wrapper

instaui/zero/func.py

@@ -1,24 +1,16 @@
 from __future__ import annotations
 import itertools
 from pathlib import Path
-from typing import Union
 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 to_html(file: Union[str, Path]):
-    if isinstance(file, str):
-        import inspect
-
-        frame = inspect.currentframe().f_back  # type: ignore
-        assert frame is not None
-        script_file = inspect.getfile(frame)
-        file = Path(script_file).parent.joinpath(file)
-
+def to_html(file: Path):
     file = Path(file)
 
     raw = to_html_str()
@@ -27,11 +19,20 @@ def to_html(file: Union[str, Path]):
     return file.resolve().absolute()
 
 
-def to_html_str():
+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
+    default_html_resource = (
+        default_app_slot._html_resource
+        if merge_global_resources
+        else _empty_html_resource()
+    )
 
     config_data = to_config_data()
 
@@ -48,13 +49,6 @@ def to_html_str():
         title=html_resource.title or default_html_resource.title or consts.PAGE_TITLE,
     )
 
-    if html_resource.use_tailwind is None:
-        if default_html_resource.use_tailwind:
-            model.js_links.append(JsLink(consts.TAILWIND_JS_PATH))
-    else:
-        if html_resource.use_tailwind:
-            model.js_links.append(JsLink(consts.TAILWIND_JS_PATH))
-
     # register custom components
     for component in system_slot._component_dependencies:
         if not component.esm:
@@ -71,6 +65,11 @@ def to_html_str():
             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(
@@ -89,15 +88,15 @@ def to_html_str():
                 model.css_links.append(css_link)
 
     # css file link to web static link
-    for link, attrs in itertools.chain(
-        html_resource._css_links.items(), default_html_resource._css_links.items()
+    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 itertools.chain(
-        html_resource._js_links, default_html_resource._js_links
+    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))
@@ -112,4 +111,13 @@ def to_html_str():
     ):
         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()