instaui 0.1.15__py2.py3-none-any.whl

instaui/js/js_output.py

@@ -0,0 +1,15 @@
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.py_binding import CanOutputMixin
+
+
+class JsOutput(Jsonable, CanOutputMixin):
+    def __init__(self):
+        self.type = "jsOutput"
+
+    def _to_output_config(self):
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        return data

instaui/js/lambda_func.py

@@ -0,0 +1,35 @@
+from typing import Dict
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+
+
+class LambdaFunc(Jsonable, ElementBindingMixin):
+    def __init__(
+        self, code: str, *, bindings: Dict[str, ElementBindingMixin], computed=False
+    ):
+        self.code = code
+        self.type = "js"
+        self._bindings = bindings
+        self._computed = computed
+
+    def _to_binding_config(self) -> Dict:
+        return self._to_json_dict()
+
+    def _to_js_binding_config(self):
+        return self._to_json_dict()
+
+    def _to_element_binding_config(self):
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        if self._bindings:
+            data["bind"] = {
+                k: v._to_element_binding_config() for k, v in self._bindings.items()
+            }
+
+        if self._computed is True:
+            data["ext"] = ["cpt"]
+
+        return data

instaui/launch_collector.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from typing import Callable, Dict, List, Optional
+from instaui.consts import _T_App_Mode
+from instaui.page_info import PageInfo
+from instaui.systems import func_system
+
+
+class LaunchCollector:
+    _instance: Optional[LaunchCollector] = None
+
+    @classmethod
+    def get_instance(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = cls(*args, **kwargs)
+        return cls._instance
+
+    def __init__(self) -> None:
+        self._page_router: Dict[str, PageInfo] = {}
+        self._page_request_lifespans: Dict[int, Callable] = {}
+        self._app_mode: _T_App_Mode = "web"
+
+    @property
+    def page_request_lifespans(self) -> List[Callable]:
+        return list(self._page_request_lifespans.values())
+
+    def register_page(self, info: PageInfo) -> None:
+        self._page_router[info.path] = info
+
+    def add_page_request_lifespan(self, lifespan: Callable) -> int:
+        """Register a function to be called on each page request.
+
+        Args:
+            lifespan (Callable):  A function to be called on each page request.
+
+        Returns:
+            int:  A unique key to identify the registered lifespan function.
+        """
+        key = id(lifespan)
+        self._page_request_lifespans[key] = func_system.make_fn_to_generator(lifespan)
+
+        return key
+
+    def remove_page_request_lifespan(self, key: int) -> None:
+        if key in self._page_request_lifespans:
+            del self._page_request_lifespans[key]
+
+    def set_app_mode(self, mode: _T_App_Mode) -> None:
+        self._app_mode = mode
+
+
+def get_launch_collector() -> LaunchCollector:
+    return LaunchCollector.get_instance()

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/runtime/__init__.py

@@ -0,0 +1,29 @@
+from ._app import (
+    get_app_slot,
+    reset_app_slot,
+    new_app_slot,
+    use_default_app_slot,
+    get_slot_stacks,
+    pop_slot,
+    get_current_scope,
+    new_scope,
+    check_default_app_slot_or_error,
+    in_default_app_slot,
+)
+from ._inner_helper import check_web_only_mode_or_error
+from .resource import HtmlResource
+
+__all__ = [
+    "get_slot_stacks",
+    "new_scope",
+    "get_current_scope",
+    "get_app_slot",
+    "reset_app_slot",
+    "new_app_slot",
+    "use_default_app_slot",
+    "pop_slot",
+    "check_web_only_mode_or_error",
+    "check_default_app_slot_or_error",
+    "in_default_app_slot",
+    "HtmlResource",
+]

instaui/runtime/_app.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Set
+from typing_extensions import Unpack, TypedDict
+from instaui.common.jsonable import Jsonable
+from .resource import HtmlResource
+from instaui.consts import _T_App_Mode
+from contextvars import ContextVar, Token
+from contextlib import contextmanager
+from instaui.runtime.scope import Scope, GlobalScope
+from types import MappingProxyType
+
+if TYPE_CHECKING:
+    from instaui.components.component import Component
+    from instaui.components.slot import Slot
+
+    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
+    _web_server_info: ClassVar[Optional[Dict]] = None
+
+    def __init__(self, *, mode: _T_App_Mode, meta: Optional[Dict] = None) -> None:
+        super().__init__()
+        self._scope_id_counter = 0
+        self._vfor_id_counter = 0
+        self._slot_id_counter = 0
+        self.mode: _T_App_Mode = mode
+        self.items: List[Component] = []
+        self.meta = meta
+        self._slots_stacks: List[Slot] = []
+
+        defalut_scope = self.create_scope()
+        self._scope_stack: List[Scope] = [defalut_scope]
+        self._scopes: List[Scope] = [defalut_scope]
+        self._html_resource = HtmlResource()
+        self._component_dependencies: Set[ComponentDependencyInfo] = set()
+        self._temp_component_dependencies: Dict[str, ComponentDependencyInfo] = {}
+        self._plugin_dependencies: Set[PluginDependencyInfo] = set()
+
+        self._page_path: Optional[str] = None
+        self._page_params: Dict[str, Any] = {}
+        self._query_params: Dict[str, Any] = {}
+        self._route_collector: Optional[RouteCollector] = None
+
+    @property
+    def page_path(self) -> str:
+        assert self._page_path is not None, "Page path is not set"
+        return self._page_path  # type: ignore
+
+    @property
+    def page_params(self):
+        return MappingProxyType(self._page_params)
+
+    @property
+    def query_params(self):
+        return MappingProxyType(self._query_params)
+
+    def create_scope(self) -> Scope:
+        self._scope_id_counter += 1
+        scope = Scope(str(self._scope_id_counter))
+        return scope
+
+    def generate_vfor_id(self) -> str:
+        self._vfor_id_counter += 1
+        return str(self._vfor_id_counter)
+
+    def generate_slot_id(self) -> str:
+        self._slot_id_counter += 1
+        return str(self._slot_id_counter)
+
+    def reset_html_resource(self):
+        self._html_resource = HtmlResource()
+
+    def add_temp_component_dependency(self, dependency: ComponentDependencyInfo):
+        self._temp_component_dependencies[dependency.tag_name] = dependency
+
+    def get_temp_component_dependency(
+        self, tag_name: str, default: ComponentDependencyInfo
+    ) -> ComponentDependencyInfo:
+        return self._temp_component_dependencies.get(tag_name, default)
+
+    def has_temp_component_dependency(self, tag_name: str):
+        return tag_name in self._temp_component_dependencies
+
+    def use_component_dependency(
+        self, dependency: ComponentDependencyInfo, *, replace=False
+    ) -> None:
+        if replace:
+            self._component_dependencies.discard(dependency)
+
+        self._component_dependencies.add(dependency)
+
+    def use_plugin_dependency(self, dependency: PluginDependencyInfo) -> None:
+        self._plugin_dependencies.add(dependency)
+
+    def register_router(self, collector: RouteCollector) -> None:
+        self._route_collector = collector
+
+    def append_component_to_container(self, component: Component):
+        if self._slots_stacks:
+            self._slots_stacks[-1]._children.append(component)
+        else:
+            self.items.append(component)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        if self._page_path:
+            url_info = {"path": self.page_path}
+            if self._page_params:
+                url_info["params"] = self._page_params  # type: ignore
+
+            data["url"] = url_info
+
+        assert len(self._scopes) == 1, "Only one scope is allowed"
+        data["scope"] = self._scopes[0]
+
+        if self._route_collector is not None:
+            data["router"] = self._route_collector.model_dump(
+                exclude_defaults=True, by_alias=True
+            )
+
+        if self._web_server_info is not None:
+            data["webInfo"] = self._web_server_info
+
+        return data
+
+    @classmethod
+    def _create_default(cls):
+        if cls._default_app_slot is None:
+            cls._default_app_slot = DefaultApp(mode="web")
+        return cls._default_app_slot
+
+
+class DefaultApp(App):
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(DefaultApp, cls).__new__(cls)
+        return cls._instance
+
+    def create_scope(self) -> Scope:
+        self._scope_id_counter += 1
+        scope = GlobalScope(str(self._scope_id_counter))
+        return scope
+
+    def append_component_to_container(self, component: Component):
+        raise ValueError("Operations are not allowed outside of ui.page")
+
+
+_app_var: ContextVar[App] = ContextVar("_app_var", default=App._create_default())
+
+
+def use_default_app_slot():
+    assert App._default_app_slot is not None, "Default app slot is not set"
+    _app_var.set(App._default_app_slot)
+
+
+def get_default_app_slot():
+    return App._create_default()
+
+
+def get_app_slot() -> App:
+    return _app_var.get()
+
+
+def get_current_scope():
+    current_scope = get_app_slot()._scope_stack[-1]
+    if current_scope is None:
+        raise ValueError("No current scope")
+    return current_scope
+
+
+@contextmanager
+def new_scope(*, append_to_app: bool = True):
+    app = get_app_slot()
+    scope = app.create_scope()
+
+    if append_to_app:
+        app._scopes.append(scope)
+
+    scope_stack = app._scope_stack
+    scope_stack.append(scope)
+
+    yield scope
+    scope_stack.pop()
+
+
+def get_slot_stacks():
+    return get_app_slot()._slots_stacks
+
+
+def pop_slot():
+    get_slot_stacks().pop()
+
+
+def new_app_slot(mode: _T_App_Mode, app_meta: Optional[Dict] = None):
+    return _app_var.set(App(mode=mode, meta=app_meta))
+
+
+def reset_app_slot(token: Token[App]):
+    _app_var.reset(token)
+
+
+def in_default_app_slot():
+    return isinstance(get_app_slot(), DefaultApp)
+
+
+def check_default_app_slot_or_error(
+    error_message="Operations are not allowed outside of ui.page",
+):
+    if isinstance(get_app_slot(), DefaultApp):
+        raise ValueError(error_message)
+
+
+class TWebServerInfo(TypedDict, total=False):
+    watch_url: Optional[str]
+    watch_async_url: Optional[str]
+    event_url: Optional[str]
+    event_async_url: Optional[str]
+
+
+def update_web_server_info(**kwargs: Unpack[TWebServerInfo]):
+    if App._web_server_info is None:
+        App._web_server_info = {}
+
+    data = {k: v for k, v in kwargs.items() if v is not None}
+
+    App._web_server_info.update(data)

instaui/runtime/_inner_helper.py

@@ -0,0 +1,9 @@
+from instaui.runtime.context import get_context
+
+
+def check_web_only_mode_or_error(method_name: str = ""):
+    mode = get_context().app_mode
+    if mode != "web" and mode != "webview":
+        raise Exception(
+            f"{method_name} This is a web-only feature. Please use the 'web' or 'webview' mode."
+        )

instaui/runtime/_link_manager.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+from typing import (
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypeVar,
+    Hashable,
+)
+
+_TLinkActionObj = TypeVar("_TLinkActionObj")
+
+_DEFAULT_KEY_FN = lambda x: x  # noqa: E731
+
+
+class LinkManager(Generic[_TLinkActionObj]):
+    def __init__(
+        self, key_fn: Optional[Callable[[_TLinkActionObj], Hashable]] = None
+    ) -> None:
+        self._key_fn = key_fn or _DEFAULT_KEY_FN
+        self._actions_map: Dict[
+            Tuple[Literal["add", "remove"], Hashable], _TLinkActionObj
+        ] = {}
+
+    def add_link(
+        self,
+        obj: _TLinkActionObj,
+    ):
+        key = ("add", self._key_fn(obj))
+        self._actions_map[key] = obj
+
+    def remove_link(
+        self,
+        obj: _TLinkActionObj,
+    ):
+        key = ("remove", self._key_fn(obj))
+        self._actions_map[key] = obj
+
+    def get_valid_links(
+        self, secondary_manager: Optional[LinkManager] = None
+    ) -> List[_TLinkActionObj]:
+        secondary_maps = secondary_manager._actions_map if secondary_manager else {}
+        merger_map = {**secondary_maps, **self._actions_map}
+
+        result = {}
+
+        for (action, key), obj in merger_map.items():
+            if action == "add":
+                result[key] = obj
+                continue
+
+            if key in result:
+                del result[key]
+
+        return list(result.values())
+
+
+if __name__ == "__main__":
+
+    def test_baes():
+        manager: LinkManager[str] = LinkManager()
+        manager.add_link("a")
+        manager.add_link("b")
+        manager.add_link("c")
+        manager.remove_link("b")
+
+        assert manager.get_valid_links() == ["a", "c"]
+
+    test_baes()
+
+    def test_with_other():
+        other: LinkManager[str] = LinkManager()
+        other.add_link("a")
+        other.add_link("b")
+        other.add_link("c")
+
+        manager1: LinkManager[str] = LinkManager()
+        manager1.add_link("b")
+        manager1.add_link("d")
+        manager1.add_link("e")
+        manager1.remove_link("a")
+        manager1.remove_link("b")
+
+        assert manager1.get_valid_links(other) == ["c", "d", "e"]
+
+    test_with_other()

instaui/runtime/context.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from instaui import consts
+from ._app import get_app_slot
+
+
+class Context:
+    _instance: Optional[Context] = None
+
+    @classmethod
+    def get_instance(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = cls(*args, **kwargs)
+        return cls._instance
+
+    def __init__(self):
+        self._app_mode: consts._T_App_Mode = "web"
+        self._debug_mode: bool = False
+        self._page_params: Dict[str, Any] = {}
+
+    @property
+    def app_mode(self):
+        return self._app_mode
+
+    @property
+    def debug_mode(self):
+        return self._debug_mode
+
+    @property
+    def page_path(self):
+        return get_app_slot().page_path
+
+    @property
+    def page_params(self):
+        return get_app_slot().page_params
+
+    @property
+    def query_params(self):
+        return get_app_slot().query_params
+
+
+def get_context():
+    return Context.get_instance()
+
+
+def set_debug(debug=True):
+    get_context()._debug_mode = debug

instaui/runtime/dataclass.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Any, Dict, Union
+from dataclasses import dataclass, field
+
+
+@dataclass
+class JsLink:
+    link: Union[str, Path]
+    attrs: Dict[str, Any] = field(default_factory=dict)
+
+    def create_attrs_str(self):
+        return " ".join(f'{k}="{v}"' for k, v in self.attrs.items() if v is not None)
+
+
+@dataclass(frozen=True)
+class VueAppUse:
+    name: str
+
+
+@dataclass(frozen=True)
+class VueAppComponent:
+    name: str
+    url: str
+
+
+@dataclass
+class ImportMaps:
+    name: str
+    url: str

instaui/runtime/resource.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set, Union
+from .dataclass import JsLink, VueAppUse, VueAppComponent
+from ._link_manager import LinkManager
+
+
+class HtmlResource:
+    use_tailwind: Optional[bool] = None
+    title: Optional[str] = None
+    favicon: Optional[Path] = None
+
+    def __init__(self) -> None:
+        self._css_links_manager: LinkManager[Union[str, Path]] = LinkManager()
+        self._style_tags: List[str] = []
+        self._js_links_manager: LinkManager[JsLink] = LinkManager(
+            key_fn=lambda js_link: js_link.link
+        )
+        self._script_tags: List[str] = []
+        self._vue_app_use: Set[VueAppUse] = set()
+        self._vue_app_components: Set[VueAppComponent] = set()
+        self._import_maps: Dict[str, str] = {}
+        self._appConfig = "{}"
+
+    def add_css_link(self, link: Union[str, Path]):
+        self._css_links_manager.add_link(link)
+
+    def remove_css_link(self, link: Union[str, Path]):
+        self._css_links_manager.remove_link(link)
+
+    def add_style_tag(self, content: str):
+        self._style_tags.append(content)
+
+    def add_js_link(
+        self,
+        link: Union[str, Path],
+        *,
+        attrs: Optional[Dict[str, Any]] = None,
+    ):
+        self._js_links_manager.add_link(JsLink(link, attrs or {}))
+
+    def remove_js_link(self, link: Union[str, Path]):
+        self._js_links_manager.remove_link(JsLink(link))
+
+    def get_valid_js_links(self, default_js_links_manager: LinkManager) -> List[JsLink]:
+        return self._js_links_manager.get_valid_links(default_js_links_manager)
+
+    def get_valid_css_links(
+        self, default_css_links_manager: LinkManager[Union[str, Path]]
+    ) -> List[Union[str, Path]]:
+        return self._css_links_manager.get_valid_links(default_css_links_manager)
+
+    def add_script_tag(
+        self, content: str, script_attrs: Optional[Dict[str, Any]] = None
+    ):
+        self._script_tags.append(content)
+
+    def add_vue_app_use(self, name: str):
+        self._vue_app_use.add(VueAppUse(name))
+
+    def add_vue_app_component(self, name: str, url: str):
+        self._vue_app_components.add(VueAppComponent(name, url))
+
+    def add_import_map(self, name: str, link: str):
+        self._import_maps[name] = link