zrb 1.0.0a21__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

zrb/cmd/cmd_val.py

@@ -1,8 +1,9 @@
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 
-from zrb.attr.type import fstring
+from zrb.attr.type import StrAttr, fstring
 from zrb.context.context import Context
+from zrb.util.attr import get_str_attr
 from zrb.util.file import read_file
 
 
@@ -13,22 +14,22 @@ class AnyCmdVal(ABC):
 
 
 class CmdPath(AnyCmdVal):
-    def __init__(self, path: str, auto_render: bool = True):
+    def __init__(self, path: StrAttr, auto_render: bool = True):
         self._path = path
         self._auto_render = auto_render
 
     def to_str(self, ctx: Context) -> str:
-        file_path = ctx.render(self._path) if self._auto_render else self._path
+        file_path = get_str_attr(ctx, self._path, "", self._auto_render)
         return read_file(file_path)
 
 
 class Cmd(AnyCmdVal):
-    def __init__(self, cmd: str, auto_render: str):
+    def __init__(self, cmd: StrAttr, auto_render: bool = True):
         self._cmd = cmd
         self._auto_render = auto_render
 
     def to_str(self, ctx: Context) -> str:
-        return ctx.render(self._cmd) if self._auto_render else self._cmd
+        return get_str_attr(ctx, self._cmd, "", self._auto_render)
 
 
 SingleCmdVal = AnyCmdVal | fstring | Callable[[Context], str]

zrb/config.py

@@ -77,7 +77,20 @@ WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES = int(
     os.getenv("ZRB_WEB_REFRESH_TOKEN_EXPIRE_MINUTES", "60")
 )
 LLM_MODEL = os.getenv("ZRB_LLM_MODEL", "ollama_chat/llama3.1")
-LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", "You are a helpful assistant")
+
+_DEFAULT_PROMPT = """
+You are a reliable assistant focused on providing accurate, helpful, and factual information.
+
+Key guidelines:
+1. Prioritize correctness and clarity.
+2. Avoid guessing—clearly state if more information is needed.
+3. Distinguish facts from opinions.
+4. Use phrases like "to the best of my knowledge" when appropriate.
+
+If unsure or lacking current data, inform the user and suggest verification.
+Accuracy always takes precedence over completeness.
+""".strip()
+LLM_SYSTEM_PROMPT = os.getenv("ZRB_LLM_SYSTEM_PROMPT", _DEFAULT_PROMPT)
 LLM_HISTORY_FILE = os.getenv(
     "ZRB_LLM_HISTORY_FILE",
     os.path.expanduser(os.path.join("~", ".zrb-llm-history.json")),

zrb/content_transformer/any_content_transformer.py

@@ -4,6 +4,13 @@ from zrb.context.any_context import AnyContext
 
 
 class AnyContentTransformer(ABC):
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Transformer's name"""
+        pass
+
     @abstractmethod
     def match(self, ctx: AnyContext, file_path: str) -> bool:
         """

zrb/content_transformer/content_transformer.py

@@ -10,6 +10,7 @@ from zrb.util.file import read_file, write_file
 class ContentTransformer(AnyContentTransformer):
     def __init__(
         self,
+        name: str,
         match: list[str] | str | Callable[[AnyContext, str], bool],
         transform: (
             dict[str, str | Callable[[AnyContext], str]]
@@ -17,10 +18,15 @@ class ContentTransformer(AnyContentTransformer):
         ),
         auto_render: bool = True,
     ):
+        self._name = name
         self._match = match
         self._transform_file = transform
         self._auto_render = auto_render
 
+    @property
+    def name(self) -> str:
+        return self._name
+
     def match(self, ctx: AnyContext, file_path: str) -> bool:
         if callable(self._match):
             return self._match(ctx, file_path)

zrb/runner/cli.py

@@ -1,17 +1,15 @@
 import sys
 from typing import Any
 
-from zrb.config import BANNER, WEB_HTTP_PORT
+from zrb.config import BANNER, VERSION, WEB_HTTP_PORT
 from zrb.context.any_context import AnyContext
 from zrb.context.shared_context import SharedContext
 from zrb.group.group import Group
 from zrb.runner.common_util import get_run_kwargs
-from zrb.runner.web_app import create_app
-from zrb.runner.web_config import web_config
+from zrb.runner.web_app import create_web_app
+from zrb.runner.web_config.config_factory import web_config
 from zrb.session.session import Session
-from zrb.session_state_logger.default_session_state_logger import (
-    default_session_state_logger,
-)
+from zrb.session_state_logger.session_state_logger_factory import session_state_logger
 from zrb.task.any_task import AnyTask
 from zrb.task.make_task import make_task
 from zrb.util.cli.style import (
@@ -151,6 +149,15 @@ class Cli(Group):
 
 
 cli = Cli(name="zrb", description="Your Automation Powerhouse", banner=BANNER)
+
+
+@make_task(
+    name="version", description="🌟 Get current Zrb version", retries=0, group=cli
+)
+def get_version(_: AnyContext):
+    return VERSION
+
+
 server_group = cli.add_group(
     Group(name="server", description="🌐 Server related command")
 )
@@ -167,6 +174,6 @@ server_group = cli.add_group(
 async def start_server(_: AnyContext):
     from uvicorn import Config, Server
 
-    app = create_app(cli, web_config, default_session_state_logger)
+    app = create_web_app(cli, web_config, session_state_logger)
     server = Server(Config(app=app, host="0.0.0.0", port=WEB_HTTP_PORT, loop="asyncio"))
     await server.serve()

zrb/runner/web_app.py

@@ -1,60 +1,38 @@
 import asyncio
-import json
-import os
 import sys
-from datetime import datetime, timedelta, timezone
-from typing import TYPE_CHECKING, Annotated
+from typing import TYPE_CHECKING
 
 from zrb.config import BANNER, VERSION
-from zrb.context.shared_context import SharedContext
 from zrb.group.any_group import AnyGroup
-from zrb.runner.common_util import get_run_kwargs
-from zrb.runner.web_config import (
-    NewSessionResponse,
-    RefreshTokenRequest,
-    Token,
-    WebConfig,
-)
-from zrb.runner.web_controller.error_page.controller import show_error_page
-from zrb.runner.web_controller.group_info_page.controller import show_group_info_page
-from zrb.runner.web_controller.home_page.controller import show_home_page
-from zrb.runner.web_controller.login_page.controller import show_login_page
-from zrb.runner.web_controller.logout_page.controller import show_logout_page
-from zrb.runner.web_controller.session_page.controller import show_session_page
-from zrb.runner.web_util import get_refresh_token_js
-from zrb.session.session import Session
-from zrb.session_state_log.session_state_log import SessionStateLog, SessionStateLogList
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_route.docs_route import serve_docs
+from zrb.runner.web_route.error_page.serve_default_404 import serve_default_404
+from zrb.runner.web_route.home_page.home_page_route import serve_home_page
+from zrb.runner.web_route.login_api_route import serve_login_api
+from zrb.runner.web_route.login_page.login_page_route import serve_login_page
+from zrb.runner.web_route.logout_api_route import serve_logout_api
+from zrb.runner.web_route.logout_page.logout_page_route import serve_logout_page
+from zrb.runner.web_route.node_page.node_page_route import serve_node_page
+from zrb.runner.web_route.refresh_token_api_route import serve_refresh_token_api
+from zrb.runner.web_route.static.static_route import serve_static_resources
+from zrb.runner.web_route.task_input_api_route import serve_task_input_api
+from zrb.runner.web_route.task_session_api_route import serve_task_session_api
 from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
-from zrb.task.any_task import AnyTask
-from zrb.util.group import NodeNotFoundError, extract_node_from_args, get_node_path
 
 if TYPE_CHECKING:
     # We want fastapi to only be loaded when necessary to decrease footprint
     from fastapi import FastAPI
 
 
-def create_app(
+def create_web_app(
     root_group: AnyGroup,
     web_config: WebConfig,
     session_state_logger: AnySessionStateLogger,
 ) -> "FastAPI":
     from contextlib import asynccontextmanager
 
-    from fastapi import (
-        Cookie,
-        Depends,
-        FastAPI,
-        HTTPException,
-        Query,
-        Request,
-        Response,
-    )
-    from fastapi.openapi.docs import get_swagger_ui_html
-    from fastapi.responses import FileResponse, HTMLResponse, PlainTextResponse
-    from fastapi.security import OAuth2PasswordRequestForm
-    from fastapi.staticfiles import StaticFiles
+    from fastapi import FastAPI
 
-    _STATIC_DIR = os.path.join(os.path.dirname(__file__), "web_controller", "static")
     _COROS = []
 
     @asynccontextmanager
@@ -75,247 +53,17 @@ def create_app(
         lifespan=lifespan,
         docs_url=None,
     )
-    app.mount("/static", StaticFiles(directory=_STATIC_DIR), name="static")
-
-    # Serve static files
-    @app.get("/static/{file_path:path}", include_in_schema=False)
-    async def static_files(file_path: str):
-        full_path = os.path.join(_STATIC_DIR, file_path)
-        if os.path.isfile(full_path):
-            return FileResponse(full_path)
-        raise HTTPException(status_code=404, detail="File not found")
-
-    @app.get("/refresh-token.js", include_in_schema=False)
-    async def refresh_token_js():
-        return PlainTextResponse(
-            content=get_refresh_token_js(
-                60 * web_config.refresh_token_expire_minutes / 3
-            ),
-            media_type="application/javascript",
-        )
-
-    @app.get("/docs", include_in_schema=False)
-    async def swagger_ui_html():
-        return get_swagger_ui_html(
-            openapi_url="/openapi.json",
-            title="Zrb",
-            swagger_favicon_url="/static/favicon-32x32.png",
-        )
-
-    # Serve homepage
-    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
-    @app.get("/ui", response_class=HTMLResponse, include_in_schema=False)
-    @app.get("/ui/", response_class=HTMLResponse, include_in_schema=False)
-    async def home_page_ui(request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        return show_home_page(user, root_group)
-
-    @app.get("/ui/{path:path}", response_class=HTMLResponse, include_in_schema=False)
-    async def ui_page(path: str, request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        # Avoid capturing '/ui' itself
-        if not path:
-            return show_error_page(user, root_group, 422, "Undefined path")
-        args = path.strip("/").split("/")
-        try:
-            node, node_path, residual_args = extract_node_from_args(root_group, args)
-        except NodeNotFoundError as e:
-            return show_error_page(user, root_group, 404, str(e))
-        url = f"/ui/{'/'.join(node_path)}/"
-        if isinstance(node, AnyTask):
-            if not user.can_access_task(node):
-                return show_error_page(user, root_group, 403, "Forbidden")
-            shared_ctx = SharedContext(env=dict(os.environ))
-            session = Session(shared_ctx=shared_ctx, root_group=root_group)
-            return show_session_page(
-                user, root_group, node, session, url, residual_args
-            )
-        elif isinstance(node, AnyGroup):
-            if not user.can_access_group(node):
-                return show_error_page(user, root_group, 403, "Forbidden")
-            return show_group_info_page(user, root_group, node, url)
-        return show_error_page(user, root_group, 404, "Not found")
-
-    @app.get("/login", response_class=HTMLResponse, include_in_schema=False)
-    async def login(request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        return show_login_page(user, root_group)
-
-    @app.get("/logout", response_class=HTMLResponse, include_in_schema=False)
-    async def logout(request: Request) -> HTMLResponse:
-        user = await web_config.get_user_from_request(request)
-        return show_logout_page(user, root_group)
-
-    @app.post("/api/v1/login")
-    async def login_api(
-        response: Response, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
-    ):
-        token = web_config.generate_tokens_by_credentials(
-            username=form_data.username, password=form_data.password
-        )
-        if token is None:
-            raise HTTPException(
-                status_code=400, detail="Incorrect username or password"
-            )
-        _set_auth_cookie(response, token)
-        return token
-
-    @app.post("/api/v1/refresh-token")
-    async def refresh_token_api(
-        response: Response,
-        body: RefreshTokenRequest = None,
-        refresh_token_cookie: str = Cookie(
-            None, alias=web_config.refresh_token_cookie_name
-        ),
-    ):
-        # Try to get the refresh token from the request body first
-        refresh_token = body.refresh_token if body else None
-        # If not in the body, try to get it from the cookie
-        if not refresh_token:
-            refresh_token = refresh_token_cookie
-        # If we still don't have a refresh token, raise an exception
-        if not refresh_token:
-            raise HTTPException(status_code=400, detail="Refresh token not provided")
-        # Get token
-        new_token = web_config.regenerate_tokens(refresh_token)
-        _set_auth_cookie(response, new_token)
-        return new_token
-
-    def _set_auth_cookie(response: Response, token: Token):
-        access_token_max_age = web_config.access_token_expire_minutes * 60
-        refresh_token_max_age = web_config.refresh_token_expire_minutes * 60
-        now = datetime.now(timezone.utc)
-        response.set_cookie(
-            key=web_config.access_token_cookie_name,
-            value=token.access_token,
-            httponly=True,
-            max_age=access_token_max_age,
-            expires=now + timedelta(seconds=access_token_max_age),
-        )
-        response.set_cookie(
-            key=web_config.refresh_token_cookie_name,
-            value=token.refresh_token,
-            httponly=True,
-            max_age=refresh_token_max_age,
-            expires=now + timedelta(seconds=refresh_token_max_age),
-        )
-
-    @app.get("/api/v1/logout")
-    @app.post("/api/v1/logout")
-    async def logout_api(response: Response):
-        response.delete_cookie(web_config.access_token_cookie_name)
-        response.delete_cookie(web_config.refresh_token_cookie_name)
-        return {"message": "Logout successful"}
-
-    @app.post("/api/v1/task-sessions/{path:path}")
-    async def create_new_task_session_api(
-        path: str,
-        request: Request,
-    ) -> NewSessionResponse:
-        """
-        Creating new session
-        """
-        user = await web_config.get_user_from_request(request)
-        args = path.strip("/").split("/")
-        task, _, residual_args = extract_node_from_args(root_group, args)
-        if isinstance(task, AnyTask):
-            if not user.can_access_task(task):
-                raise HTTPException(status_code=403)
-            session_name = residual_args[0] if residual_args else None
-            if not session_name:
-                body = await request.json()
-                shared_ctx = SharedContext(env=dict(os.environ))
-                session = Session(shared_ctx=shared_ctx, root_group=root_group)
-                coro = asyncio.create_task(task.async_run(session, str_kwargs=body))
-                _COROS.append(coro)
-                coro.add_done_callback(lambda coro: _COROS.remove(coro))
-                return NewSessionResponse(session_name=session.name)
-        raise HTTPException(status_code=404)
-
-    @app.get("/api/v1/task-inputs/{path:path}", response_model=dict[str, str])
-    async def get_default_inputs_api(
-        path: str,
-        request: Request,
-        query: str = Query("{}", description="JSON encoded inputs"),
-    ) -> dict[str, str]:
-        """
-        Getting input completion for path
-        """
-        user = await web_config.get_user_from_request(request)
-        args = path.strip("/").split("/")
-        task, _, _ = extract_node_from_args(root_group, args)
-        if isinstance(task, AnyTask):
-            if not user.can_access_task(task):
-                raise HTTPException(status_code=403)
-            query_dict = json.loads(query)
-            run_kwargs = get_run_kwargs(
-                task=task, args=[], kwargs=query_dict, prompt=False
-            )
-            return run_kwargs
-        raise HTTPException(status_code=404, detail="Not Found")
-
-    @app.get(
-        "/api/v1/task-sessions/{path:path}",
-        response_model=SessionStateLog | SessionStateLogList,
-    )
-    async def get_session_api(
-        path: str,
-        request: Request,
-        min_start_query: str = Query(default=None, alias="from"),
-        max_start_query: str = Query(default=None, alias="to"),
-        page: int = Query(default=0, alias="page"),
-        limit: int = Query(default=10, alias="limit"),
-    ) -> SessionStateLog | SessionStateLogList:
-        """
-        Getting existing session or sessions
-        """
-        user = await web_config.get_user_from_request(request)
-        args = path.strip("/").split("/")
-        task, _, residual_args = extract_node_from_args(root_group, args)
-        if isinstance(task, AnyTask) and residual_args:
-            if not user.can_access_task(task):
-                raise HTTPException(status_code=403)
-            if residual_args[0] == "list":
-                task_path = get_node_path(root_group, task)
-                max_start_time = (
-                    datetime.now()
-                    if max_start_query is None
-                    else datetime.strptime(max_start_query, "%Y-%m-%d %H:%M:%S")
-                )
-                min_start_time = (
-                    max_start_time - timedelta(hours=1)
-                    if min_start_query is None
-                    else datetime.strptime(min_start_query, "%Y-%m-%d %H:%M:%S")
-                )
-                return _get_existing_sessions(
-                    task_path, min_start_time, max_start_time, page, limit
-                )
-            else:
-                return _read_session(residual_args[0])
-        raise HTTPException(status_code=404, detail="Not Found")
-
-    def _get_existing_sessions(
-        task_path: list[str],
-        min_start_time: datetime,
-        max_start_time: datetime,
-        page: int,
-        limit: int,
-    ) -> SessionStateLogList:
-        try:
-            return session_state_logger.list(
-                task_path,
-                min_start_time=min_start_time,
-                max_start_time=max_start_time,
-                page=page,
-                limit=limit,
-            )
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
-
-    def _read_session(session_name: str) -> SessionStateLog:
-        try:
-            return session_state_logger.read(session_name)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
 
+    serve_default_404(app, root_group, web_config)
+    serve_static_resources(app, web_config)
+    serve_docs(app)
+    serve_home_page(app, root_group, web_config)
+    serve_login_page(app, root_group, web_config)
+    serve_logout_page(app, root_group, web_config)
+    serve_node_page(app, root_group, web_config)
+    serve_login_api(app, web_config)
+    serve_logout_api(app, web_config)
+    serve_refresh_token_api(app, web_config)
+    serve_task_input_api(app, root_group, web_config)
+    serve_task_session_api(app, root_group, web_config, session_state_logger, _COROS)
     return app

zrb/runner/web_config/config.py

@@ -0,0 +1,91 @@
+from typing import Callable
+
+from zrb.runner.web_schema.user import User
+from zrb.task.any_task import AnyTask
+
+
+class WebConfig:
+    def __init__(
+        self,
+        port: int,
+        secret_key: str,
+        access_token_expire_minutes: int,
+        refresh_token_expire_minutes: int,
+        access_token_cookie_name: str,
+        refresh_token_cookie_name: str,
+        enable_auth: bool,
+        super_admin_username: str,
+        super_admin_password: str,
+        guest_username: str,
+        guest_accessible_tasks: list[AnyTask | str] = [],
+        find_user_by_username: Callable[[str], User | None] | None = None,
+    ):
+        self.secret_key = secret_key
+        self.access_token_expire_minutes = access_token_expire_minutes
+        self.refresh_token_expire_minutes = refresh_token_expire_minutes
+        self.access_token_cookie_name = access_token_cookie_name
+        self.refresh_token_cookie_name = refresh_token_cookie_name
+        self.enable_auth = enable_auth
+        self.port = port
+        self._user_list = []
+        self.super_admin_username = super_admin_username
+        self.super_admin_password = super_admin_password
+        self.guest_username = guest_username
+        self.guest_accessible_tasks = guest_accessible_tasks
+        self._find_user_by_username = find_user_by_username
+
+    @property
+    def default_user(self) -> User:
+        if self.enable_auth:
+            return User(
+                username=self.guest_username,
+                password="",
+                is_guest=True,
+                accessible_tasks=self.guest_accessible_tasks,
+            )
+        return User(
+            username=self.guest_username,
+            password="",
+            is_guest=True,
+            is_super_admin=True,
+        )
+
+    @property
+    def super_admin(self) -> User:
+        return User(
+            username=self.super_admin_username,
+            password=self.super_admin_password,
+            is_super_admin=True,
+        )
+
+    @property
+    def user_list(self) -> list[User]:
+        if not self.enable_auth:
+            return [self.default_user]
+        return self._user_list + [self.super_admin, self.default_user]
+
+    def set_guest_accessible_tasks(self, tasks: list[AnyTask | str]):
+        self.guest_accessible_tasks = tasks
+
+    def set_find_user_by_username(
+        self, find_user_by_username: Callable[[str], User | None]
+    ):
+        self._find_user_by_username = find_user_by_username
+
+    def append_user(self, user: User):
+        duplicates = [
+            existing_user
+            for existing_user in self.user_list
+            if existing_user.username == user.username
+        ]
+        if len(duplicates) > 0:
+            raise ValueError(f"User already exists {user.username}")
+        self._user_list.append(user)
+
+    def find_user_by_username(self, username: str) -> User | None:
+        user = None
+        if self._find_user_by_username is not None:
+            user = self._find_user_by_username(username)
+        if user is None:
+            user = next((u for u in self.user_list if u.username == username), None)
+        return user

zrb/runner/web_config/config_factory.py

@@ -0,0 +1,26 @@
+from zrb.config import (
+    WEB_ACCESS_TOKEN_COOKIE_NAME,
+    WEB_AUTH_ACCESS_TOKEN_EXPIRE_MINUTES,
+    WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES,
+    WEB_ENABLE_AUTH,
+    WEB_GUEST_USERNAME,
+    WEB_HTTP_PORT,
+    WEB_REFRESH_TOKEN_COOKIE_NAME,
+    WEB_SECRET_KEY,
+    WEB_SUPER_ADMIN_PASSWORD,
+    WEB_SUPER_ADMIN_USERNAME,
+)
+from zrb.runner.web_config.config import WebConfig
+
+web_config = WebConfig(
+    port=WEB_HTTP_PORT,
+    secret_key=WEB_SECRET_KEY,
+    access_token_expire_minutes=WEB_AUTH_ACCESS_TOKEN_EXPIRE_MINUTES,
+    refresh_token_expire_minutes=WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES,
+    access_token_cookie_name=WEB_ACCESS_TOKEN_COOKIE_NAME,
+    refresh_token_cookie_name=WEB_REFRESH_TOKEN_COOKIE_NAME,
+    enable_auth=WEB_ENABLE_AUTH,
+    super_admin_username=WEB_SUPER_ADMIN_USERNAME,
+    super_admin_password=WEB_SUPER_ADMIN_PASSWORD,
+    guest_username=WEB_GUEST_USERNAME,
+)

zrb/runner/web_route/docs_route.py

@@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_docs(app: "FastAPI") -> None:
+    from fastapi.openapi.docs import get_swagger_ui_html
+
+    @app.get("/docs", include_in_schema=False)
+    async def swagger_ui_html():
+        return get_swagger_ui_html(
+            openapi_url="/openapi.json",
+            title="Zrb",
+            swagger_favicon_url="/static/favicon-32x32.png",
+        )

zrb/runner/web_route/error_page/serve_default_404.py

@@ -0,0 +1,28 @@
+from typing import TYPE_CHECKING
+
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_route.error_page.show_error_page import show_error_page
+from zrb.runner.web_util.user import get_user_from_request
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_default_404(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.exception_handlers import http_exception_handler
+    from fastapi.responses import HTMLResponse
+
+    @app.exception_handler(404)
+    async def default_404(request: Request, exc: Exception) -> HTMLResponse:
+        if request.url.path.startswith("/api"):
+            # Re-raise the exception to let FastAPI handle it
+            return await http_exception_handler(request, exc)
+        user = await get_user_from_request(web_config, request)
+        return show_error_page(user, root_group, 404, "Not found")

zrb/runner/{web_controller/error_page/controller.py → web_route/error_page/show_error_page.py}

@@ -1,8 +1,8 @@
 import os
 
 from zrb.group.any_group import AnyGroup
-from zrb.runner.web_config import User
-from zrb.runner.web_util import get_html_auth_link
+from zrb.runner.web_schema.user import User
+from zrb.runner.web_util.html import get_html_auth_link
 from zrb.util.file import read_file
 from zrb.util.string.format import fstring_format
 
@@ -23,5 +23,6 @@ def show_error_page(user: User, root_group: AnyGroup, status_code: int, message:
                 "error_status_code": status_code,
                 "error_message": message,
             },
-        )
+        ),
+        status_code=status_code,
     )