instaui 0.1.1__tar.gz → 0.1.3__tar.gz

{instaui-0.1.1 → instaui-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: instaui
-Version: 0.1.1
+Version: 0.1.3
 Summary: insta-ui is a Python-based UI library for rapidly building user interfaces.
 License: MIT
 Author: CrystalWindSnake

{instaui-0.1.1 → instaui-0.1.3}/instaui/components/component.py

@@ -22,7 +22,7 @@ class Component(Jsonable):
 
         self.tag = (
             "div"
-            if tag is None
+            if tag is None or tag == ""
             else (
                 tag._to_element_binding_config()
                 if isinstance(tag, ElementBindingMixin)

{instaui-0.1.1 → instaui-0.1.3}/instaui/components/element.py

@@ -13,6 +13,7 @@ from typing import (
     Optional,
     Tuple,
     Union,
+    cast,
     overload,
     TYPE_CHECKING,
 )
@@ -21,11 +22,11 @@ from collections import defaultdict
 from instaui.runtime._app import get_app_slot
 from instaui.runtime._app import get_current_scope
 from instaui.vars.element_ref import ElementRef
-
-
 from instaui.vars.vfor_item import VForItem
 from instaui.components.directive import Directive
-from instaui.dependencies import ComponentRegistrationInfo, register_component
+from instaui.dependencies.component_dependency import (
+    ComponentDependencyInfo,
+)
 from .slot import SlotManager, Slot
 from instaui import consts
 from instaui.components.component import Component
@@ -69,14 +70,14 @@ PROPS_PATTERN = re.compile(
 
 
 class Element(Component):
-    component: ClassVar[Optional[ComponentRegistrationInfo]] = None
+    dependency: ClassVar[Optional[ComponentDependencyInfo]] = None
     _default_props: ClassVar[Dict[str, Any]] = {}
     _default_classes: ClassVar[List[str]] = []
     _default_style: ClassVar[Dict[str, str]] = {}
 
     def __init__(self, tag: Optional[Union[str, ElementBindingMixin]] = None):
-        if self.component:
-            tag = self.component.name
+        if self.dependency:
+            tag = self.dependency.tag_name or ""
 
         super().__init__(tag)
 
@@ -101,19 +102,28 @@ class Element(Component):
     def __init_subclass__(
         cls,
         *,
-        component: Union[str, Path, None] = None,
+        esm: Union[str, Path, None] = None,
+        externals: Optional[List[Union[str, Path]]] = None,
+        css: Union[List[Union[str, Path]], None] = None,
     ) -> None:
         super().__init_subclass__()
 
-        if component:
-            if isinstance(component, str):
-                component = Path(component)
-                if not component.is_absolute():
-                    component = Path(inspect.getfile(cls)).parent / component
+        if esm:
+            esm = _make_dependency_path(esm, cls)
+
+            if externals:
+                externals = [_make_dependency_path(e, cls) for e in externals]
+
+            if css:
+                css = [_make_dependency_path(c, cls) for c in css]
 
-            # TODO: Lazy load component registration
-            cls.component = register_component(
-                component.stem, esm=component, shared=True
+            tag_name = f"instaui-{esm.stem}"
+
+            cls.dependency = ComponentDependencyInfo(
+                tag_name=tag_name,
+                esm=esm,
+                externals=cast(List[Path], externals or []),
+                css=cast(List[Path], css or []),
             )
 
         cls._default_props = copy(cls._default_props)
@@ -365,8 +375,8 @@ class Element(Component):
         if self._directives:
             data["dir"] = list(self._directives.keys())
 
-        if self.component:
-            get_app_slot().register_component(self.component)
+        if self.dependency:
+            get_app_slot().use_component_dependency(self.dependency)
 
         if self._element_ref:
             scope = get_current_scope()
@@ -460,3 +470,13 @@ def _classifyBindableDict(
             value_data[key] = value
 
     return value_data, bind_data
+
+
+def _make_dependency_path(path: Union[str, Path], cls: type):
+    if isinstance(path, str):
+        path = Path(path)
+
+    if not path.is_absolute():
+        path = Path(inspect.getfile(cls)).parent / path
+
+    return path

{instaui-0.1.1 → instaui-0.1.3}/instaui/components/html/checkbox.py

@@ -31,12 +31,5 @@ class Checkbox(InputEventMixin, ValueElement[Union[bool, str]]):
         if model_value is not None:
             self.props({"value": model_value})
 
-    # def vmodel(
-    #     self,
-    #     value: Any,
-    #     *modifiers: Literal["trim"] | Literal["number"] | Literal["lazy"],
-    # ):
-    #     return super().vmodel(value, *modifiers)  # type: ignore
-
     def _input_event_mixin_element(self) -> Element:
         return self

{instaui-0.1.1 → instaui-0.1.3}/instaui/components/html/select.py

@@ -7,10 +7,10 @@ from typing import (
     List,
     Literal,
     Optional,
-    Self,
     Union,
     overload,
 )
+from typing_extensions import Self
 
 from instaui.vars import Ref
 from instaui.components.value_element import ValueElement

{instaui-0.1.1 → instaui-0.1.3}/instaui/components/vfor.py

@@ -60,7 +60,7 @@ class VFor(Component, Generic[_T]):
     def __enter__(self) -> _T:
         self.__scope = self.__scope_manager.__enter__()
         super().__enter__()
-        return VForItem(self).proxy
+        return VForItem(self).proxy # type: ignore
 
     def __exit__(self, *_) -> None:
         self.__scope_manager.__exit__(*_)

{instaui-0.1.1 → instaui-0.1.3}/instaui/consts.py

@@ -8,11 +8,15 @@ _STATIC_DIR = _THIS_DIR.joinpath("static")
 INDEX_TEMPLATE_PATH = _TEMPLATES_DIR.joinpath("index.html")
 APP_IIFE_JS_PATH = _STATIC_DIR.joinpath("insta-ui.iife.js")
 APP_ES_JS_PATH = _STATIC_DIR.joinpath("insta-ui.esm-browser.prod.js")
+APP_ES_JS_MAP_PATH = _STATIC_DIR.joinpath("insta-ui.js.map")
 APP_CSS_PATH = _STATIC_DIR.joinpath("insta-ui.css")
 VUE_IIFE_JS_PATH = _STATIC_DIR.joinpath("vue.global.prod.js")
 VUE_ES_JS_PATH = _STATIC_DIR.joinpath("vue.esm-browser.prod.js")
 VUE_ES_RUNTIME_JS_PATH = _STATIC_DIR.joinpath("vue.runtime.esm-browser.prod.js")
 TAILWIND_JS_PATH = _STATIC_DIR.joinpath("tailwindcss.min.js")
+FAVICON_PATH = _STATIC_DIR.joinpath("insta-ui.ico")
+
+PAGE_TITLE = "insta-ui"
 
 _T_App_Mode = Literal["zero", "web", "webview"]
 TModifier = Literal["trim", "number", "lazy"]

instaui-0.1.3/instaui/dependencies/component_dependency.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+_TTagName = str
+
+
+@dataclass(frozen=True)
+class ComponentDependencyInfo:
+    tag_name: _TTagName = field(hash=True)
+    esm: Path = field(hash=False)
+    externals: Optional[List[Path]] = field(
+        default_factory=list, compare=False, hash=False
+    )
+    css: List[Path] = field(default_factory=list, compare=False, hash=False)

instaui-0.1.3/instaui/dependencies/plugin_dependency.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+from instaui.runtime._app import get_app_slot
+
+
+@dataclass(frozen=True)
+class PluginDependencyInfo:
+    name: str = field(hash=True)
+    esm: Path = field(hash=False)
+    externals: Optional[List[Path]] = field(
+        default_factory=list, compare=False, hash=False
+    )
+    css: List[Path] = field(default_factory=list, compare=False, hash=False)
+
+
+def register_plugin(
+    name: str,
+    esm: Path,
+    *,
+    externals: Optional[List[Path]] = None,
+    css: Optional[List[Path]] = None,
+):
+    info = PluginDependencyInfo(f"plugin/{name}", esm, externals or [], css or [])
+
+    get_app_slot().use_plugin_dependency(info)
+    return info

{instaui-0.1.1 → instaui-0.1.3}/instaui/fastapi_server/debug_mode_router.py

@@ -24,7 +24,6 @@ async def event_generator(
     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():

instaui-0.1.3/instaui/fastapi_server/dependency_router.py

@@ -0,0 +1,21 @@
+from fastapi import FastAPI
+from fastapi.responses import FileResponse
+
+from instaui.fastapi_server import resource
+
+
+URL = f"{resource.URL}/{{hash_part:path}}"
+
+
+def create_router(app: FastAPI):
+    _dependency_handler(app)
+
+
+def _dependency_handler(app: FastAPI):
+    @app.get(URL)
+    def _(hash_part: str) -> FileResponse:
+        local_file = resource.get_by_hash(hash_part)
+
+        return FileResponse(
+            local_file, headers={"Cache-Control": "public, max-age=3600"}
+        )

instaui-0.1.3/instaui/fastapi_server/resource.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+from typing import Dict
+from instaui.systems import file_system
+from instaui.version import __version__ as _INSTA_VERSION
+
+URL = f"/_instaui_{_INSTA_VERSION}/resource"
+_THashPart = str
+_HASH_PART_MAP: Dict[_THashPart, Path] = {}
+_FILE_URL_MAP: Dict[Path, _THashPart] = {}
+
+
+def get_by_hash(hash_part: str) -> Path:
+    return _HASH_PART_MAP[hash_part]
+
+
+def record_resource(path: Path):
+    if path in _FILE_URL_MAP:
+        return _FILE_URL_MAP[path]
+
+    hash_part = _generate_hash_part(path)
+    _HASH_PART_MAP[hash_part] = path
+    url = f"{URL}/{hash_part}"
+    _FILE_URL_MAP[path] = url
+    return url
+
+
+def _generate_hash_part(path: Path):
+    path = Path(path).resolve()
+    is_file = path.is_file()
+
+    if is_file:
+        return f"{file_system.generate_hash_name_from_path(path.parent)}/{path.name}"
+
+    return file_system.generate_hash_name_from_path(path)

instaui-0.1.3/instaui/fastapi_server/server.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+from contextlib import contextmanager
+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.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}"
+TAILWIND_JS_HASH_LINK = f"{INSTAUI_STATIC_URL}/{consts.TAILWIND_JS_PATH.name}"
+FAVICON_LINK = f"{INSTAUI_STATIC_URL}/{consts.FAVICON_PATH.name}"
+
+
+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)
+        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()
+
+    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,
+        )
+
+        if html_resource.use_tailwind is None:
+            if default_html_resource.use_tailwind:
+                model.js_links.append(JsLink(TAILWIND_JS_HASH_LINK))
+        else:
+            if html_resource.use_tailwind:
+                model.js_links.append(JsLink(TAILWIND_JS_HASH_LINK))
+
+        # 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:
+                    model.css_links.append(resource.record_resource(css_link))
+
+        # 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, attrs in itertools.chain(
+            html_resource._css_links.items(), default_html_resource._css_links.items()
+        ):
+            if isinstance(link, Path):
+                model.css_links.append(resource.record_resource(link))
+
+        # js file link to web static link
+        for info in itertools.chain(
+            html_resource._js_links, default_html_resource._js_links
+        ):
+            if isinstance(info.link, Path):
+                model.js_links.append(JsLink((resource.record_resource(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)
+
+        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-0.1.3/instaui/html_tools.py

@@ -0,0 +1,53 @@
+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
+
+
+def add_css_link(href: Union[str, Path]):
+    get_app_slot()._html_resource.add_css_link(href)
+
+
+def add_js_link(
+    link: Union[str, Path],
+    *,
+    type: Optional[Literal["module"]] = None,
+):
+    attrs = {
+        "type": type,
+    }
+
+    get_app_slot()._html_resource.add_js_link(link, attrs=attrs)
+
+
+def add_style(content: str):
+    get_app_slot()._html_resource.add_style_tag(content)
+
+
+def use_tailwind(value=True):
+    get_app_slot()._html_resource.use_tailwind = value
+
+
+def use_page_title(title: str):
+    get_app_slot()._html_resource.title = title
+
+
+def use_favicon(favicon: Path):
+    get_app_slot()._html_resource.favicon = favicon
+
+
+def add_js_code(code: str, *, script_attrs: Optional[Dict[str, Any]] = 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-0.1.3/instaui/page_info.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from typing import Callable
+from dataclasses import dataclass
+from urllib.parse import quote
+
+
+@dataclass
+class PageInfo:
+    path: str
+    func: Callable
+
+    def create_key(self) -> str:
+        return quote(self.path)