instaui 0.1.0__py3-none-any.whl

instaui/html_tools.py

@@ -0,0 +1,139 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Dict, Literal, Optional, Union
+import instaui.consts as consts
+from instaui.common.jsonable import dumps, dumps2dict
+from instaui.runtime import get_app_slot, HtmlResource
+from instaui.template import render_zero_html
+
+
+def add_css_link(href: Union[str, Path], *, shared: bool = False):
+    if shared:
+        HtmlResource.default_css_link(href)
+
+    get_app_slot()._html_resource.add_css_link(href)
+
+
+def add_js_link(
+    link: Union[str, Path],
+    *,
+    shared: bool = False,
+    type: Optional[Literal["module", "importmap"]] = None,
+):
+    attrs = {
+        "type": type,
+    }
+
+    if shared:
+        HtmlResource.default_js_link(link, attrs=attrs)
+
+    get_app_slot()._html_resource.add_js_link(link, attrs=attrs)
+
+
+def add_style(content: str, *, shared: bool = False):
+    if shared:
+        HtmlResource.default_style_tag(content)
+    get_app_slot()._html_resource.add_style_tag(content)
+
+
+def add_js_code(code: str, *, shared: bool = False):
+    if shared:
+        HtmlResource.default_script_tag(code)
+    get_app_slot()._html_resource.add_script_tag(code)
+
+
+def add_vue_app_use(name: str, *, shared: bool = False):
+    if shared:
+        HtmlResource.default_vue_app_use(name)
+    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)
+
+
+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)
+
+    file = Path(file)
+    system_slot = get_app_slot()
+    html_resource = system_slot._html_resource
+
+    if html_resource.use_tailwind:
+        html_resource.add_js_link(consts.TAILWIND_JS_PATH, insert_before=0)
+    html_resource.add_js_link(consts.APP_IIFE_JS_PATH, insert_before=0)
+    html_resource.add_js_link(consts.VUE_IIFE_JS_PATH, insert_before=0)
+    html_resource.add_css_link(consts.APP_CSS_PATH)
+
+    # register custom components
+    for component in system_slot._js_components:
+        if not component.iife:
+            continue
+
+        html_resource.add_js_link(component.iife)
+
+        if component.css:
+            for css_link in component.css:
+                html_resource.add_css_link(css_link)
+
+        html_resource.add_vue_app_use(component.name)
+
+    for plugin in system_slot._plugins:
+        if not plugin.iife:
+            continue
+
+        html_resource.add_js_link(plugin.iife)
+
+        if plugin.css:
+            for css_link in plugin.css:
+                html_resource.add_css_link(css_link)
+
+        html_resource.add_vue_app_use(plugin.name)
+
+    _css_file_link_to_style_code(html_resource)
+    _js_file_link_to_script_code(html_resource)
+
+    raw = render_zero_html(to_json())
+    file.write_text(raw, "utf8")
+
+    return file.resolve().absolute()
+
+
+def _css_file_link_to_style_code(html_resource: HtmlResource):
+    files = [link for link in html_resource._css_links.keys() if isinstance(link, Path)]
+
+    for file in files:
+        content = file.read_text(encoding="utf-8")
+        html_resource.add_style_tag(content)
+
+    # remove file links
+    html_resource._css_links = {
+        link: None
+        for link in html_resource._css_links.keys()
+        if not isinstance(link, Path)
+    }
+
+
+def _js_file_link_to_script_code(html_resource: HtmlResource):
+    files = (
+        info.link for info in html_resource._js_links if isinstance(info.link, Path)
+    )
+
+    for file in files:
+        content = file.read_text(encoding="utf-8")
+        html_resource.add_script_tag(content)
+
+    # remove file links
+    html_resource._js_links = [
+        info for info in html_resource._js_links if not isinstance(info.link, Path)
+    ]

instaui/inject.py

@@ -0,0 +1,33 @@
+import typing
+from instaui.runtime import ui_state_scope
+
+
+_T = typing.TypeVar("_T")
+
+
+def injection_key(key: str) -> _T:
+    """ creates a key for injection
+
+    Args:
+        key (str): key to use for injection
+
+    Example:
+    .. code-block:: python
+        text_key :str = injection_key("text")
+
+        # state model
+        class Person(ui.StateModel):
+            name:str
+
+        person_key :Person = injection_key(Person(name='foo'))
+    """    
+    return key  # type: ignore
+
+
+def inject_state(key: _T) -> _T:
+    return typing.cast(_T, ui_state_scope.load_state(key))  # type: ignore
+
+
+def provide_state(key: _T, obj: _T) -> _T:
+    ui_state_scope.save_state(key, obj)
+    return obj

instaui/js/__init__.py

@@ -0,0 +1,4 @@
+from .lambda_func import LambdaFunc as func
+
+
+__all__ = ["func"]

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,23 @@
+from __future__ import annotations
+from typing import Callable, Optional, TYPE_CHECKING
+from dataclasses import dataclass
+from urllib.parse import quote
+
+
+if TYPE_CHECKING:
+    from instaui.runtime.resource import HtmlResource
+
+
+@dataclass
+class PageInfo:
+    path: str
+    func: Callable
+    page_loading: Optional[Callable] = None
+    use_tailwind: Optional[bool] = None
+
+    def create_key(self) -> str:
+        return quote(self.path)
+
+    def apply_settings(self, html_resource: HtmlResource):
+        if self.use_tailwind is not None:
+            html_resource.use_tailwind = self.use_tailwind

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,206 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, List, Optional, Set
+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
+
+if TYPE_CHECKING:
+    from instaui.components.component import Component
+    from instaui.components.slot import Slot
+    from instaui.dependencies import ComponentRegistrationInfo, PluginRegistrationInfo
+    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__()
+        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._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._js_components: Set[ComponentRegistrationInfo] = copy(
+            self._default_js_components
+        )
+
+        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] = {}
+        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 register_component(self, component: ComponentRegistrationInfo) -> None:
+        self._js_components.add(component)
+
+    def register_plugin(self, plugin: PluginRegistrationInfo) -> None:
+        self._plugins.add(plugin)
+
+    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
+            )
+
+        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
+
+    @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
+
+    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):
+    return _app_var.set(App(mode=mode))
+
+
+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)

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/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