instaui 0.1.0__tar.gz → 0.1.2__tar.gz

{instaui-0.1.0 → instaui-0.1.2}/PKG-INFO

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

{instaui-0.1.0 → instaui-0.1.2}/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.0 → instaui-0.1.2}/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.0 → instaui-0.1.2}/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.0 → instaui-0.1.2}/instaui/components/slot.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Dict, List, Optional, Set, Union
+from typing import TYPE_CHECKING, Dict, List, Optional, Set
 from instaui.common.jsonable import Jsonable
 from instaui.runtime import get_slot_stacks, pop_slot
 from instaui.runtime._app import get_app_slot
@@ -8,7 +8,6 @@ from instaui.vars.slot_prop import BindingSlotPropItem
 
 if TYPE_CHECKING:
     from instaui.components.component import Component
-    from instaui.components.vfor import VFor
 
 _DEFAULT_SLOT_NAME = ":"
 
@@ -50,7 +49,7 @@ class Slot(Jsonable):
 
         self._id: Optional[str] = None
         self._name = name
-        self._children: List[Union[Component, VFor]] = []
+        self._children: List[Component] = []
         self._props_use_name: Set[str] = set()
 
     def _has_props_use(self):

{instaui-0.1.0 → instaui-0.1.2}/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.2/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.2/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.0 → instaui-0.1.2}/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.2/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.2/instaui/fastapi_server/resource.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+from typing import Dict
+from urllib.parse import quote as urllib_quote
+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_static_url(file_path: Path):
+    return urllib_quote(f"{URL}/{_generate_hash_part(file_path)}")
+
+
+def _generate_hash_part(file_path: Path):
+    file_path = Path(file_path).resolve()
+    hash_name = file_system.generate_hash_name_from_path(file_path)
+    return f"{hash_name}/{file_path.name}"

instaui-0.1.2/instaui/fastapi_server/server.py

@@ -0,0 +1,270 @@
+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.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
+
+APP_IMPORT_STRING = "instaui.fastapi_server.server:Server._instance.app"
+
+VUE_JS_HASH_LINK = resource.record_resource(consts.VUE_ES_JS_PATH)
+INSTAUI_JS_HASH_LINK = resource.record_resource(consts.APP_ES_JS_PATH)
+APP_CSS_LINK = resource.record_resource(consts.APP_CSS_PATH)
+TAILWIND_JS_HASH_LINK = resource.record_resource(consts.TAILWIND_JS_PATH)
+
+
+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)
+
+        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()
+
+        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,
+        )
+
+        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.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"
+
+
+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.2/instaui/html_tools.py

@@ -0,0 +1,45 @@
+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 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.2/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)

{instaui-0.1.0 → instaui-0.1.2}/instaui/runtime/_app.py

@@ -5,7 +5,6 @@ from instaui.common.jsonable import Jsonable
 from .resource import HtmlResource
 from instaui.consts import _T_App_Mode
 from contextvars import ContextVar, Token
-from copy import copy
 from contextlib import contextmanager
 from instaui.runtime.scope import Scope, GlobalScope
 from types import MappingProxyType
@@ -13,14 +12,14 @@ from types import MappingProxyType
 if TYPE_CHECKING:
     from instaui.components.component import Component
     from instaui.components.slot import Slot
-    from instaui.dependencies import ComponentRegistrationInfo, PluginRegistrationInfo
+
+    from instaui.dependencies.component_dependency import ComponentDependencyInfo
+    from instaui.dependencies.plugin_dependency import PluginDependencyInfo
     from instaui.spa_router._route_model import RouteCollector
 
 
 class App(Jsonable):
     _default_app_slot: ClassVar[Optional[App]] = None
-    _default_js_components: ClassVar[Set[ComponentRegistrationInfo]] = set()
-    _default_plugins: ClassVar[Set[PluginRegistrationInfo]] = set()
 
     def __init__(self, *, mode: _T_App_Mode) -> None:
         super().__init__()
@@ -35,11 +34,9 @@ class App(Jsonable):
         self._scope_stack: List[Scope] = [defalut_scope]
         self._scopes: List[Scope] = [defalut_scope]
         self._html_resource = HtmlResource()
-        self._js_components: Set[ComponentRegistrationInfo] = copy(
-            self._default_js_components
-        )
+        self._component_dependencies: Set[ComponentDependencyInfo] = set()
+        self._plugin_dependencies: Set[PluginDependencyInfo] = set()
 
-        self._plugins: Set[PluginRegistrationInfo] = copy(self._default_plugins)
         self._page_path: Optional[str] = None
         self._page_params: Dict[str, Any] = {}
         self._query_params: Dict[str, Any] = {}
@@ -74,11 +71,11 @@ class App(Jsonable):
     def reset_html_resource(self):
         self._html_resource = HtmlResource()
 
-    def register_component(self, component: ComponentRegistrationInfo) -> None:
-        self._js_components.add(component)
+    def use_component_dependency(self, dependency: ComponentDependencyInfo) -> None:
+        self._component_dependencies.add(dependency)
 
-    def register_plugin(self, plugin: PluginRegistrationInfo) -> None:
-        self._plugins.add(plugin)
+    def use_plugin_dependency(self, dependency: PluginDependencyInfo) -> None:
+        self._plugin_dependencies.add(dependency)
 
     def register_router(self, collector: RouteCollector) -> None:
         self._route_collector = collector
@@ -115,14 +112,6 @@ class App(Jsonable):
             cls._default_app_slot = DefaultApp(mode="web")
         return cls._default_app_slot
 
-    @classmethod
-    def default_js_components(cls, component: ComponentRegistrationInfo):
-        cls._default_js_components.add(component)
-
-    @classmethod
-    def default_plugins(cls, plugin: PluginRegistrationInfo):
-        cls._default_plugins.add(plugin)
-
 
 class DefaultApp(App):
     _instance = None