instaui 0.1.15__py2.py3-none-any.whl

instaui/spa_router/_file_base_utils.py

@@ -0,0 +1,273 @@
+from __future__ import annotations
+from collections import deque
+from datetime import datetime
+import importlib.util
+from pathlib import Path
+import typing
+import jinja2
+import inspect
+from dataclasses import dataclass, field
+
+
+def build_routes_from_files(
+    folder_path: typing.Union[str, Path] = "pages",
+    module_name: str = "_routes",
+    route_config_var_name: str = "_route_config",
+):
+    global_args = _GlobalArgs(
+        base_folder_path=_utils.get_caller_path().parent / Path(folder_path),
+        module_name=module_name,
+        route_config_var_name=route_config_var_name,
+    )
+
+    root = _model_utils.create_root(global_args)
+    _code_gen.generate_router_file(root)
+
+    print(f"Build _routes from files in {global_args.base_folder_path}...")
+
+
+@dataclass
+class _GlobalArgs:
+    base_folder_path: Path
+    module_name: str
+    route_config_var_name: str
+
+
+class _model_utils:
+    @dataclass
+    class FileRouteInfo:
+        file: Path
+        base_folder: Path
+        global_args: _GlobalArgs
+        children: typing.List[_model_utils.FileRouteInfo] = field(default_factory=list)
+        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="")
+        meta: typing.Dict = field(init=False, default_factory=dict)
+
+        def __post_init__(self):
+            self.params = self._extract_params()
+            self.meta = self._extract_meta()
+            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_sync_index_info(self, index_info: _model_utils.FileRouteInfo):
+            self.fn_path = index_info.fn_path
+            self.path = self.path + index_info.params
+            self.meta = index_info.meta
+
+        def _extract_params(self):
+            if self.file.is_file():
+                route_config = _module_utils.get_module_getter(self.file)(
+                    self.global_args.route_config_var_name
+                )
+                if route_config:
+                    if "params" in route_config:
+                        return route_config["params"]
+
+            return ""
+
+        def _extract_meta(self):
+            if self.file.is_file():
+                route_config = _module_utils.get_module_getter(self.file)(
+                    self.global_args.route_config_var_name
+                )
+
+                if route_config:
+                    if "meta" in route_config:
+                        return route_config["meta"]
+
+            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.replace(' ','_')} import main as {self.main_fn_name()}"
+
+        def main_fn_name(self):
+            if not self.fn_path:
+                return ""
+            return self.name.replace(".", "_").replace(" ", "_")
+
+    @dataclass
+    class FileRouteRoot:
+        folder: str
+        module_name: str
+        infos: list[_model_utils.FileRouteInfo] = field(default_factory=list)
+
+    @staticmethod
+    def create_root(global_args: _GlobalArgs) -> FileRouteRoot:
+        base_folder = Path(global_args.base_folder_path)
+        infos = _model_utils._create_route_info(base_folder, global_args)
+        return _model_utils.FileRouteRoot(
+            folder=str(base_folder), module_name=global_args.module_name, infos=infos
+        )
+
+    @staticmethod
+    def _create_route_info(
+        base_folder: Path, global_args: _GlobalArgs
+    ) -> 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, global_args=global_args
+                )
+                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, global_args=global_args
+            )
+
+            if parent_info is None:
+                result.append(file_info)
+            else:
+                if file_info.is_index_file():
+                    parent_info.change_sync_index_info(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"),
+    )
+
+    @dataclass
+    class TemplateModel:
+        update_time: datetime = field(default_factory=datetime.now)
+        route_names: typing.List[str] = field(default_factory=list)
+        routes: typing.List[_model_utils.FileRouteInfo] = field(default_factory=list)
+
+        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 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.
+
+    Examples:
+    .. 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)

instaui/spa_router/_route_model.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+import typing
+from pydantic import BaseModel, Field, ConfigDict, field_serializer, model_serializer
+
+from instaui.components.html.div import Div
+from instaui.runtime._app import get_app_slot, new_scope
+from instaui.components.component import Component
+from instaui.runtime.scope import Scope
+from instaui.common.jsonable import dumps2dict
+
+from . import _types
+
+
+class RouteItem(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    component_fn: typing.Optional[typing.Callable] = Field(exclude=True)
+    scope: typing.Optional[Scope] = None
+    vue_route_item: VueRouteItem = Field(serialization_alias="vueItem")
+    meta: typing.Optional[typing.Dict] = None
+
+    @model_serializer
+    def model_ser(self):
+        if self.component_fn is None and (not self.vue_route_item.path):
+            raise ValueError("Either component_fn or vue_route_item.path must be set")
+
+        if self.component_fn is None:
+            return {
+                "vueItem": self.vue_route_item,
+            }
+
+        if self.vue_route_item.path is None:
+            self.vue_route_item.path = f"/{'' if self.component_fn.__name__=='index' else self.component_fn.__name__}"
+
+        app = get_app_slot()
+        with new_scope(append_to_app=False) as scope:
+            with Div() as div:
+                self.component_fn()
+
+        app.items.pop()
+
+        self.scope = scope
+        self.vue_route_item.component = div._slot_manager.default._children
+
+        return {
+            "scope": dumps2dict(scope),
+            "vueItem": self.vue_route_item,
+        }
+
+    @classmethod
+    def create(
+        cls,
+        *,
+        component_fn: typing.Optional[typing.Callable] = None,
+        path: typing.Optional[str] = None,
+        name: typing.Optional[str] = None,
+        params: typing.Optional[typing.Dict[str, str]] = None,
+        children: typing.Optional[typing.List[RouteItem]] = None,
+        meta: typing.Optional[typing.Dict] = None,
+    ):
+        """Create a new RouteItem
+
+        Examples:
+        .. 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:
+            component_fn (typing.Callable): function that returns a component to be rendered.
+            path (typing.Optional[str], optional): route path. Defaults to None.
+            name (typing.Optional[str], optional): route name. Defaults to None.
+            params (typing.Optional[typing.Dict[str, str]], optional): route params. Defaults to None.
+            children (typing.Optional[typing.List[RouteItem]], optional): child routes. Defaults to None.
+
+        """
+
+        return cls(
+            component_fn=component_fn,
+            meta=meta,
+            vue_route_item=VueRouteItem(
+                path=path,
+                name=name,
+                params=params,
+                component=[],
+                children=children,
+            ),
+        )
+
+
+class VueRouteItem(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    path: typing.Optional[str] = None
+    params: typing.Optional[typing.Dict[str, str]] = None
+    name: typing.Optional[str] = None
+    component: typing.Optional[typing.List[Component]] = []
+    children: typing.Optional[typing.List[RouteItem]] = None
+
+    @field_serializer("component")
+    def serialize_component(self, value: typing.List[Component]):
+        if not value:
+            return []
+        return dumps2dict(value)
+
+
+class RouteCollector(BaseModel):
+    mode: _types.TRouterHistoryMode = "hash"
+    keep_alive: bool = Field(default=False, serialization_alias="kAlive")
+    routes: typing.List[RouteItem] = []
+
+    def add_route(self, item: RouteItem):
+        self.routes.append(item)
+        return self

instaui/spa_router/_router_box.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+from typing import Dict, List
+from instaui.common.jsonable import Jsonable
+from instaui.components.component import Component
+from instaui.runtime.scope import Scope
+
+from . import _types
+from ._route_model import RouteCollector
+
+
+class RouterBox_(Jsonable):
+    def __init__(self):
+        self._mode: _types.TRouterHistoryMode = "web"
+        self._keep_alive: bool = False
+        self._component_map: Dict[str, Dict] = {}
+        self._route_collector: RouteCollector = RouteCollector()
+
+    def add_component(
+        self,
+        path: str,
+        components: List[Component],
+        scope: Scope,
+        lazy_loading: bool = False,
+    ):
+        config = {"items": components, "scope": scope}
+        if lazy_loading:
+            config["lazy"] = True
+
+        self._component_map[path] = config
+
+    def _to_json_dict(self):
+        data = {}
+
+        data["routes"] = self._route_collector.model_dump(exclude_none=True)["routes"]
+        data["mode"] = self._mode
+
+        if self._keep_alive is not False:
+            data["kAlive"] = self._keep_alive
+
+        return data

instaui/spa_router/_router_output.py

@@ -0,0 +1,22 @@
+from typing import List, Optional
+from instaui.common.jsonable import Jsonable
+from instaui.vars.mixin_types.py_binding import CanOutputMixin
+from pydantic import BaseModel
+
+
+class RouterOutput(Jsonable, CanOutputMixin):
+    def __init__(self):
+        self.type = "routeAct"
+
+    def _to_output_config(self):
+        return self._to_json_dict()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+
+        return data
+
+
+class RouterMethod(BaseModel):
+    fn: str
+    args: Optional[List]

instaui/spa_router/_router_param_var.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import typing
+
+from instaui.common.jsonable import Jsonable
+from instaui.vars.path_var import PathVar
+
+from instaui.vars.mixin_types.element_binding import ElementBindingMixin
+from instaui.vars.mixin_types.observable import ObservableMixin
+from instaui.vars.mixin_types.str_format_binding import StrFormatBindingMixin
+from instaui.vars.mixin_types.pathable import CanPathPropMixin
+
+
+class RouterParamsVar(
+    Jsonable,
+    PathVar,
+    ObservableMixin,
+    CanPathPropMixin,
+    StrFormatBindingMixin,
+    ElementBindingMixin,
+):
+    VAR_TYPE = "routePar"
+
+    def __init__(
+        self,
+        prop: typing.Literal["params", "path", "fullPath"] = "params",
+    ) -> None:
+        super().__init__()
+        self._prop = prop
+
+    def __to_binding_config(self):
+        return self._to_json_dict()
+
+    def _to_pathable_binding_config(self) -> typing.Dict:
+        return self.__to_binding_config()
+
+    def _to_path_prop_binding_config(self) -> typing.Dict:
+        return self.__to_binding_config()
+
+    def _to_observable_config(self):
+        return self.__to_binding_config()
+
+    def _to_element_binding_config(self):
+        return self.__to_binding_config()
+
+    def _to_json_dict(self):
+        data = super()._to_json_dict()
+        data["type"] = self.VAR_TYPE
+
+        if self._prop != "params":
+            data["prop"] = self._prop
+        return data

instaui/spa_router/_types.py

@@ -0,0 +1,4 @@
+import typing
+
+
+TRouterHistoryMode = typing.Literal["web", "memory", "hash"]

instaui/spa_router/templates/page_routes

@@ -0,0 +1,60 @@
+{% macro render_fn_arg(main_fn_name) -%}
+    {% if main_fn_name -%}
+    component_fn={{main_fn_name}},
+    {% endif -%}
+{% endmacro -%}
+
+{% macro render_children_arg(children) -%}
+    {% if children -%}
+    children=[
+        {{render_routes(children)}}],
+    {% endif -%}
+{% endmacro -%}
+
+
+{% macro render_routes(routes) -%}
+
+{% if not routes -%}
+
+{% else -%}
+    {% for route in routes -%}
+    router.RouteItem.create(
+        path="{{route.path}}", 
+        name="{{route.name}}", 
+        meta = {{route.meta}},
+        {{ render_fn_arg(route.main_fn_name()) |trim}}
+        {{ render_children_arg(route.children) |trim}}
+    ),
+    {% endfor -%}
+
+{% endif -%}
+
+{% endmacro -%}
+
+"""
+This file is automatically generated by InstaUI. Do not modify it manually.
+
+update: {{model.update_time}}
+"""
+
+import typing
+from instaui import spa_router as router
+
+TNames = typing.Literal{{model.route_names}}
+
+def link(text: str, name: TNames, params: typing.Optional[typing.Dict] = None):
+    return router.link.by_name(text, name=name, params=params)
+
+def get_routes():
+    try:
+        {% for code in model.get_all_main_import() -%}
+        {{code}}
+        {% endfor -%}
+
+        return [
+        {{render_routes(model.routes)}}
+    ]
+    except Exception as e:
+        print(f"router error: {e}")
+
+