instaui 0.1.0__py3-none-any.whl

instaui/runtime/resource.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+from pathlib import Path
+from typing import Any, ClassVar, Dict, List, Optional, Set, Union
+from .dataclass import JsLink, VueAppUse, VueAppComponent
+
+
+class HtmlResource:
+    _default_css_links: ClassVar[Dict[Union[str, Path], Any]] = {}
+    _default_style_tags: ClassVar[List[str]] = []
+    _default_js_links: ClassVar[List[JsLink]] = []
+    _default_script_tags: ClassVar[List[str]] = []
+    _default_vue_app_use: ClassVar[Set[VueAppUse]] = set()
+    _default_vue_app_components: ClassVar[Set[VueAppComponent]] = set()
+    use_tailwind: bool = False
+    _title: str = ""
+
+    def __init__(self) -> None:
+        self._css_links: Dict[Union[str, Path], Any] = self._default_css_links.copy()
+        self._style_tags: List[str] = self._default_style_tags.copy()
+        self._js_links: List[JsLink] = self._default_js_links.copy()
+        self._script_tags: List[str] = self._default_script_tags.copy()
+        self._vue_app_use: Set[VueAppUse] = self._default_vue_app_use.copy()
+        self._vue_app_components: Set[VueAppComponent] = (
+            self._default_vue_app_components.copy()
+        )
+        self._import_maps: Dict[str, str] = {}
+        self.title: str = self._title
+        self._appConfig = "{}"
+
+    def add_css_link(self, link: Union[str, Path]):
+        self._css_links[link] = None
+
+    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,
+        insert_before: int = -1,
+    ):
+        if insert_before == -1:
+            self._js_links.append(JsLink(link, attrs or {}))
+            return
+        self._js_links.insert(insert_before, JsLink(link, attrs or {}))
+
+    def add_script_tag(self, content: str):
+        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
+
+    @classmethod
+    def default_css_link(cls, link: Union[str, Path]):
+        cls._default_css_links[link] = None
+
+    @classmethod
+    def default_style_tag(cls, content: str):
+        cls._default_style_tags.append(content)
+
+    @classmethod
+    def default_js_link(
+        cls,
+        link: Union[str, Path],
+        *,
+        attrs: Optional[Dict[str, Any]] = None,
+        insert_before: int = -1,
+    ):
+        if insert_before == -1:
+            cls._default_js_links.append(JsLink(link, attrs or {}))
+            return
+        cls._default_js_links.insert(insert_before, JsLink(link, attrs or {}))
+
+    @classmethod
+    def default_script_tag(cls, content: str):
+        cls._default_script_tags.append(content)
+
+    @classmethod
+    def default_vue_app_use(cls, name: str):
+        cls._default_vue_app_use.add(VueAppUse(name))

instaui/runtime/scope.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+from instaui.common.jsonable import Jsonable
+
+
+if TYPE_CHECKING:
+    from instaui.vars.mixin_types.var_type import VarMixin
+    from instaui.vars.mixin_types.py_binding import CanInputMixin
+    from instaui.vars.web_computed import WebComputed
+    from instaui.watch.web_watch import WebWatch
+    from instaui.watch.js_watch import JsWatch
+    from instaui.watch.vue_watch import VueWatch
+    from instaui.vars.element_ref import ElementRef
+
+
+class Scope(Jsonable):
+    def __init__(self, id: str) -> None:
+        super().__init__()
+        self.id = id
+        self._vars_id_counter = 0
+        self._element_ref_id_counter = 0
+        self._vars: List[VarMixin] = []
+        self._web_computeds: List[WebComputed] = []
+        self._element_refs: List[ElementRef] = []
+        self._run_method_records: List = []
+        self._web_watchs: List[WebWatch] = []
+        self._js_watchs: List[JsWatch] = []
+        self._vue_watchs: List[VueWatch] = []
+        self._query = {}
+
+    def set_run_method_record(
+        self, scope_id: str, element_ref_id: str, method_name: str, args
+    ):
+        self._run_method_records.append((scope_id, element_ref_id, method_name, args))
+
+    def generate_vars_id(self) -> str:
+        self._vars_id_counter += 1
+        return str(self._vars_id_counter)
+
+    def generate_element_ref_id(self) -> str:
+        self._element_ref_id_counter += 1
+        return str(self._element_ref_id_counter)
+
+    def register_element_ref(self, ref: ElementRef):
+        self._element_refs.append(ref)
+
+    def set_query(self, url: str, key: str, on: List[CanInputMixin]) -> None:
+        self._query = {
+            "url": url,
+            "key": key,
+            "on": [v._to_input_config() for v in on],
+        }
+
+    def register_var(self, var: VarMixin) -> None:
+        self._vars.append(var)
+
+    def register_web_computed(self, computed: WebComputed) -> None:
+        self._web_computeds.append(computed)
+
+    def register_web_watch(self, watch: WebWatch) -> None:
+        self._web_watchs.append(watch)
+
+    def register_js_watch(self, watch: JsWatch) -> None:
+        self._js_watchs.append(watch)
+
+    def register_vue_watch(self, watch: VueWatch) -> None:
+        self._vue_watchs.append(watch)
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        if self._vars:
+            data["vars"] = self._vars
+        if self._query:
+            data["query"] = self._query
+        if self._web_watchs:
+            data["py_watch"] = self._web_watchs
+        if self._js_watchs:
+            data["js_watch"] = self._js_watchs
+        if self._vue_watchs:
+            data["vue_watch"] = self._vue_watchs
+        if self._element_refs:
+            data["eRefs"] = self._element_refs
+        if self._web_computeds:
+            data["web_computed"] = self._web_computeds
+
+        return data
+
+
+class GlobalScope(Scope):
+    def __init__(self, id: str) -> None:
+        super().__init__(id)
+
+    def register_var(self, var: VarMixin) -> None:
+        raise ValueError("Can not register vars in global scope")
+
+    def register_web_computed(self, computed: WebComputed) -> None:
+        raise ValueError("Can not register web_computeds  in global scope")
+
+    def register_web_watch(self, watch: WebWatch) -> None:
+        raise ValueError("Can not register web_watchs  in global scope")
+
+    def register_js_watch(self, watch: JsWatch) -> None:
+        raise ValueError("Can not register js_watchs  in global scope")
+
+    def register_vue_watch(self, watch: VueWatch) -> None:
+        raise ValueError("Can not register vue_watchs  in global scope")

instaui/runtime/ui_state_scope.py

@@ -0,0 +1,15 @@
+import contextvars
+from typing import Dict
+
+
+_scope_var: contextvars.ContextVar[Dict[type, object]] = contextvars.ContextVar(
+    "_scope_var", default={}
+)
+
+
+def save_state(key, obj: object) -> None:
+    _scope_var.get()[key] = obj
+
+
+def load_state(key) -> object:
+    return _scope_var.get()[key]

instaui/settings/__init__.py

@@ -0,0 +1,4 @@
+from .__settings import use_tailwind
+
+
+__all__ = ["use_tailwind"]

instaui/settings/__settings.py

@@ -0,0 +1,13 @@
+from instaui.runtime import in_default_app_slot, HtmlResource
+
+
+def use_tailwind(value=True):
+    """Use Tailwind CSS framework.
+
+    Args:
+        value (bool, optional):  whether to use Tailwind CSS. Defaults to True.
+    """
+
+    if not in_default_app_slot():
+        raise ValueError("Cannot set use_tailwind outside of ui.page")
+    HtmlResource.use_tailwind = value

instaui/skip.py

@@ -0,0 +1,12 @@
+from typing import Any
+
+
+class _Skip:
+    pass
+
+
+skip_output = _Skip()
+
+
+def is_skip_output(value: Any):
+    return value is skip_output

instaui/spa_router/__init__.py

@@ -0,0 +1,26 @@
+from ._components import RouterLink as link, RouterView as view
+from ._functions import (
+    add_route,
+    config_router,
+    get_params,
+    get_full_path,
+    get_path,
+    push,
+    output,
+)
+from ._route_model import RouteItem
+from ._file_base_utils import build_routes_from_files
+
+__all__ = [
+    "add_route",
+    "config_router",
+    "link",
+    "view",
+    "get_params",
+    "get_full_path",
+    "get_path",
+    "push",
+    "output",
+    "RouteItem",
+    "build_routes_from_files",
+]

instaui/spa_router/_components.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+import typing
+from instaui import html
+from instaui.components.element import Element
+from instaui.vars.types import TMaybeRef
+
+
+class RouterLink(Element):
+    def __init__(self, text: TMaybeRef[str], *, to: str):
+        super().__init__("router-link")
+
+        self.props({"to": to})
+
+        if text is not None:
+            with self.add_slot("default"):
+                html.span(text)
+
+    @classmethod
+    def by_name(
+        cls,
+        text: TMaybeRef[str],
+        *,
+        name: str,
+        params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    ) -> RouterLink:
+        to: typing.Dict = {"name": name}
+        if params:
+            to["params"] = params
+
+        return cls(text, to=to)  # type: ignore
+
+
+class RouterView(Element):
+    def __init__(self):
+        super().__init__("router-view")

instaui/spa_router/_file_base_utils.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+from collections import deque
+from datetime import datetime
+import importlib.util
+from pathlib import Path
+import sys
+import typing
+from pydantic import BaseModel, Field
+import jinja2
+import inspect
+
+
+def build_routes_from_files(
+    folder_path: typing.Union[str, Path] = "pages",
+    module_name: str = "_routes",
+):
+    folder_path = _utils.get_caller_path().parent / Path(folder_path)
+    root = _model_utils.create_root(folder_path, module_name)
+    _code_gen.generate_router_file(root)
+
+    print(f"Build _routes from files in {folder_path}...")
+    # _module_utils.reload_module_from_folder(folder_path, module_name)
+
+
+class _model_utils:
+    class FileRouteInfo(BaseModel):
+        file: Path
+        base_folder: Path
+        children: typing.List[_model_utils.FileRouteInfo] = []
+
+        path: str = Field(init=False, default="")
+        name: str = Field(init=False, default="")
+        fn_path: typing.Optional[str] = Field(init=False, default=None)
+
+        params: str = Field(init=False, default="")
+
+        def model_post_init(self, __context) -> None:
+            self.params = self._extract_params()
+            self.path, self.name = self._extra_path_name()
+
+            if self.file.is_file():
+                self.fn_path = ".".join(
+                    self.file.relative_to(self.base_folder).with_suffix("").parts
+                )
+
+        def is_index_file(self):
+            return self.file.is_file() and self.file.stem == "index"
+
+        def change_index(self, index_info: _model_utils.FileRouteInfo):
+            self.fn_path = index_info.fn_path
+            self.path = self.path + index_info.params
+
+        def _extract_params(self):
+            if self.file.is_file():
+                route_config = _module_utils.get_module_getter(self.file)(
+                    "_route_config"
+                )
+                if route_config:
+                    if "params" in route_config:
+                        return route_config["params"]
+
+            return ""
+
+        def _extra_path_name(self):
+            name_parts = list(
+                self.file.relative_to(self.base_folder).with_suffix("").parts
+            )
+
+            is_root = len(name_parts) == 1
+
+            path = self.file.stem
+            if path == "index":
+                path = ""
+
+            name = ".".join(name_parts)
+
+            if is_root:
+                path = "/" + path
+
+            if self.params:
+                path += self.params
+
+            return path, name
+
+        def import_code(self):
+            if not self.fn_path:
+                return ""
+
+            return f"from .{self.fn_path} import main as {self.main_fn_name()}"
+
+        def main_fn_name(self):
+            if not self.fn_path:
+                return ""
+            return self.name.replace(".", "_")
+
+    class FileRouteRoot(BaseModel):
+        folder: str
+        module_name: str
+        infos: list[_model_utils.FileRouteInfo] = []
+
+    @staticmethod
+    def create_root(folder: Path, module_name: str) -> FileRouteRoot:
+        base_folder = Path(folder)
+        infos = _model_utils._create_route_info(base_folder)
+        return _model_utils.FileRouteRoot(
+            folder=str(base_folder), module_name=module_name, infos=infos
+        )
+
+    @staticmethod
+    def _create_route_info(base_folder: Path) -> typing.List[FileRouteInfo]:
+        result: typing.List[_model_utils.FileRouteInfo] = []
+
+        stack: deque[
+            typing.Tuple[typing.Optional[_model_utils.FileRouteInfo], Path]
+        ] = deque()
+        stack.extendleft((None, path) for path in base_folder.iterdir())
+
+        while stack:
+            parent_info, item = stack.pop()
+            is_dir = item.is_dir()
+
+            if item.stem.startswith("_"):
+                continue
+
+            if is_dir:
+                folder_info = _model_utils.FileRouteInfo(
+                    file=item, base_folder=base_folder
+                )
+                infos = ((folder_info, path) for path in item.iterdir())
+                stack.extendleft(infos)
+
+                if parent_info is None:
+                    result.append(folder_info)
+                else:
+                    parent_info.children.append(folder_info)
+                continue
+
+            if item.suffix != ".py":
+                continue
+
+            file_info = _model_utils.FileRouteInfo(file=item, base_folder=base_folder)
+
+            if parent_info is None:
+                result.append(file_info)
+            else:
+                if file_info.is_index_file():
+                    parent_info.change_index(file_info)
+
+                else:
+                    parent_info.children.append(file_info)
+
+        return result
+
+    @staticmethod
+    def iter_route_info(infos: typing.List[FileRouteInfo]):
+        stack: typing.List[_model_utils.FileRouteInfo] = []
+        stack.extend(infos)
+
+        while stack:
+            info = stack.pop()
+            stack.extend(info.children)
+            yield info
+
+
+class _code_gen:
+    _env = jinja2.Environment(
+        loader=jinja2.PackageLoader("instaui.spa_router", "templates"),
+    )
+
+    class TemplateModel(BaseModel):
+        update_time: datetime = Field(default_factory=datetime.now)
+        route_names: typing.List[str] = []
+        routes: typing.List[_model_utils.FileRouteInfo] = []
+
+        def get_all_main_import(self):
+            return [
+                info.import_code() for info in _model_utils.iter_route_info(self.routes)
+            ]
+
+    @staticmethod
+    def generate_router_file(root: _model_utils.FileRouteRoot):
+        _template = _code_gen._env.get_template("page_routes")
+
+        template_model = _code_gen.TemplateModel(
+            route_names=_code_gen._extract_all_route_names(root), routes=root.infos
+        )
+
+        code = _template.render(model=template_model)
+        Path(root.folder).joinpath(f"{root.module_name}.py").write_text(
+            code, encoding="utf-8"
+        )
+
+    @staticmethod
+    def _extract_all_route_names(root: _model_utils.FileRouteRoot):
+        return [
+            info.name
+            for info in _model_utils.iter_route_info(root.infos)
+            if info.fn_path
+        ]
+
+
+class _module_utils:
+    @staticmethod
+    def reload_module_from_folder(folder: Path, module_name: str):
+        module_file_path = folder / f"{module_name}.py"
+
+        if not module_file_path.exists():
+            raise FileNotFoundError(f"No such file: '{module_file_path}'")
+
+        package_name = module_file_path.parent.name
+        spec = importlib.util.spec_from_file_location(
+            module_name, str(module_file_path)
+        )
+        if spec is None:
+            raise ImportError(f"Failed to load module: '{module_name}'")
+
+        module = importlib.util.module_from_spec(spec)
+        module.__package__ = package_name
+
+        if module_name in sys.modules:
+            sys.modules[module_name] = module
+            importlib.reload(module)
+            return
+
+        spec.loader.exec_module(module)  # type: ignore
+
+    @staticmethod
+    def get_module_getter(path: Path):
+        if not isinstance(path, Path):
+            raise ValueError("Expected a Path object")
+
+        if not path.exists():
+            raise FileNotFoundError(f"The file {path} does not exist.")
+
+        module_name = path.stem
+        module_path = str(path.absolute())
+
+        spec = importlib.util.spec_from_file_location(module_name, module_path)
+        if spec is None:
+            raise ImportError(f"Cannot create a module spec for {module_path}")
+
+        module = importlib.util.module_from_spec(spec)
+
+        try:
+            spec.loader.exec_module(module)  # type: ignore
+        except Exception as e:
+            raise ImportError(f"Failed to import {module_path}: {e}")
+
+        def getter_fn(var_name: str):
+            return getattr(module, var_name, None)
+
+        return getter_fn
+
+
+class _utils:
+    @staticmethod
+    def get_caller_path():
+        current_frame = inspect.currentframe()
+        try:
+            caller_frame = current_frame.f_back.f_back  # type: ignore
+            filename = caller_frame.f_code.co_filename  # type: ignore
+            return Path(filename)
+        finally:
+            del current_frame

instaui/spa_router/_functions.py

@@ -0,0 +1,122 @@
+import typing
+from . import _types
+from instaui.runtime._app import get_app_slot
+from . import _install
+from ._router_param_var import RouterParamsVar
+from ._router_output import RouterOutput, RouterMethod
+from ._route_model import RouteItem
+
+_ASSERT_MSG = "Router is not initialized."
+
+
+def add_route(
+    page_fn: typing.Callable,
+    *,
+    name: typing.Optional[str] = None,
+    path: typing.Optional[str] = None,
+    children: typing.Optional[typing.List[RouteItem]] = None,
+    lazy_loading: bool = False,
+):
+    _install.try_register_router_collector()
+    route_collector = get_app_slot()._route_collector
+    assert route_collector is not None, _ASSERT_MSG
+    route_collector.add_route(
+        RouteItem.create(
+            path=path,
+            component_fn=page_fn,
+            name=name,
+            children=children,
+        )
+    )
+
+
+def config_router(
+    routes: typing.Optional[typing.List[RouteItem]] = None,
+    *,
+    history: _types.TRouterHistoryMode = "hash",
+    keep_alive: bool = False,
+):
+    """Configure the router.
+
+    Example:
+    .. code-block:: python
+        routes = [
+            spa_router.RouteItem.create(path='/',component_fn=home),
+            spa_router.RouteItem.create(path='/user',component_fn=user_home),
+        ]
+
+        spa_router.config_router(routes=routes)
+
+    Args:
+        routes (typing.Optional[typing.List[RouteItem]], optional): list of routes to be added to the router. Defaults to None.
+        history (_types.TRouterHistoryMode, optional): router history mode. Can be "web", "memory" or "hash". Defaults to "hash".
+        keep_alive (bool, optional): whether to keep the components alive when navigating to a new route.Defaults to False.
+    """
+
+    _install.try_register_router_collector()
+
+    route_collector = get_app_slot()._route_collector
+    assert route_collector is not None, _ASSERT_MSG
+
+    route_collector.mode = history
+    route_collector.keep_alive = keep_alive
+    route_collector.routes = routes or []
+
+
+def get_params(param_name: str) -> typing.Any:
+    return RouterParamsVar("params")[param_name]
+
+
+def get_path():
+    return RouterParamsVar("path")
+
+
+def get_full_path():
+    return RouterParamsVar("fullPath")
+
+
+def push(
+    *,
+    path: typing.Optional[str] = None,
+    name: typing.Optional[str] = None,
+    params: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    query: typing.Optional[typing.Dict[str, typing.Any]] = None,
+    hash: typing.Optional[str] = None,
+):
+    method_params: typing.Dict = {}
+
+    if path is not None:
+        method_params["path"] = path
+    if name is not None:
+        method_params["name"] = name
+
+    if params is not None:
+        method_params["params"] = params
+    if query is not None:
+        method_params["query"] = query
+    if hash is not None:
+        method_params["hash"] = hash
+
+    return RouterMethod(
+        fn="push",
+        args=[method_params],
+    )
+
+
+def go(n: int):
+    return RouterMethod(
+        fn="go",
+        args=[n],
+    )
+
+
+def forward():
+    return go(1)
+
+
+def back():
+    return go(-1)
+
+
+def output():
+    return RouterOutput()

instaui/spa_router/_install.py

@@ -0,0 +1,11 @@
+from instaui.runtime._app import get_app_slot
+from instaui.spa_router._route_model import RouteCollector
+
+
+def try_register_router_collector():
+    app = get_app_slot()
+    if app._route_collector is not None:
+        return
+
+    rb = RouteCollector()
+    app.register_router(rb)