instaui 0.1.15__py2.py3-none-any.whl

instaui/webview/index.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+from contextlib import contextmanager
+from pathlib import Path
+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.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/__init__.py

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

instaui/zero/func.py

@@ -0,0 +1,123 @@
+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 to_html(file: Path):
+    file = Path(file)
+
+    raw = to_html_str()
+    file.write_text(raw, "utf8")
+
+    return file.resolve().absolute()
+
+
+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/zero/scope.py

@@ -0,0 +1,109 @@
+from pathlib import Path
+from typing import Dict, Optional, Union
+from instaui.runtime import new_app_slot, reset_app_slot
+from contextlib import contextmanager
+from .func import to_html, to_html_str, get_template_model
+from instaui.template.zero_template import ZeroTemplateModel
+
+
+@contextmanager
+def scope(app_meta: Optional[Dict] = None):
+    token = new_app_slot("zero", app_meta)
+    yield Wrapper()
+    reset_app_slot(token)
+
+
+class Wrapper:
+    def to_html(self, file: Union[str, Path]):
+        file = self._get_caller_path(file)
+        return to_html(file)
+
+    def to_html_str(self):
+        return to_html_str()
+
+    def to_debug_report(self, file: Union[str, Path]):
+        file = self._get_caller_path(file)
+
+        # Custom component dependencies must be recorded only during actual execution
+        result_html_str = to_html_str()
+        model = get_template_model()
+        with scope(app_meta={"merge_global_resources": False}) as s:
+            _create_debug_report(model, result_html_str)
+            s.to_html(file.resolve().absolute())
+
+    @staticmethod
+    def _get_caller_path(file: Union[str, Path]) -> Path:
+        if isinstance(file, str):
+            import inspect
+
+            frame = inspect.currentframe().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
+
+
+def _create_debug_report(model: ZeroTemplateModel, result_html_str: str):
+    from instaui import ui, html, arco
+
+    no_exists_path_class = "ex-no-exists-path"
+
+    def _path_exists_class(path: Path):
+        return "" if path.exists() else no_exists_path_class
+
+    ui.use_tailwind()
+
+    ui.add_style(rf".{no_exists_path_class} {{background-color: red;color: white;}}")
+
+    html_size = len(result_html_str.encode("utf-8")) / 1024 / 1024
+
+    box_style = "border-2 border-gray-200 p-4 place-center gap-x-2"
+
+    with ui.column().classes("gap-2"):
+        # base info
+        with ui.grid(columns="auto 1fr").classes(box_style):
+            html.span("file size:")
+            html.span(f"{html_size:.2f} MB")
+
+        # import maps
+        html.paragraph("import maps")
+
+        rows = [
+            ["vue", str(model.vue_js_code)],
+            ["instaui", str(model.instaui_js_code)],
+        ]
+
+        for name, url in model.extra_import_maps.items():
+            if isinstance(url, Path) and url.is_file():
+                rows.append([name, str(url)])
+
+        arco.table(columns=["name", "path"], data=rows)
+
+        # css links
+        html.paragraph("css links")
+        with ui.column().classes(box_style):
+            for link in model.css_links:
+                if isinstance(link, Path) and link.is_file():
+                    html.span(str(link)).classes(_path_exists_class(link))
+
+        # js links
+        html.paragraph("js links")
+        with ui.column().classes(box_style):
+            for info in model.js_links:
+                if isinstance(info.link, Path) and info.link.is_file():
+                    html.span(str(info.link)).classes(_path_exists_class(info.link))
+
+        # custom components
+        html.paragraph("custom components")
+        with ui.grid(columns="auto 1fr").classes(box_style):
+            html.span("name")
+            html.span("js file path")
+
+            for info in model.vue_app_component:
+                html.span(info.name)
+
+                if isinstance(info.url, Path) and info.url.is_file():
+                    html.span(str(info.url)).classes(_path_exists_class(info.url))
+                else:
+                    html.span("not file")