zrb 1.0.0a20__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

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
 

zrb/runner/{web_controller → web_route}/error_page/view.html

@@ -1,5 +1,6 @@
 <!doctype html>
 <html lang="en">
+
     <head>
         <meta charset="utf-8">
         <meta name="viewport" content="width=device-width, initial-scale=1">
@@ -9,6 +10,7 @@
         <title>Zrb</title>
         <link rel="stylesheet" href="/static/common.css">
     </head>
+
     <body>
         <header class="container">
             <hgroup>
@@ -26,8 +28,12 @@
             </hgroup>
         </header>
         <main class="container">
+            <article>
                 <h2>{error_status_code}</h2>
                 <p>{error_message}</p>
+            </article>
         </main>
     </body>
+    <script src="/refresh-token.js"></script>
+
 </html>

zrb/runner/web_route/home_page/home_page_route.py

@@ -0,0 +1,51 @@
+import os
+from typing import TYPE_CHECKING
+
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.html import (
+    get_html_auth_link,
+    get_html_subgroup_info,
+    get_html_subtask_info,
+)
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.util.file import read_file
+from zrb.util.string.format import fstring_format
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_home_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+
+    # 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:
+
+        _DIR = os.path.dirname(__file__)
+        _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+        user = await get_user_from_request(web_config, request)
+        group_info = get_html_subgroup_info(user, "/ui/", root_group)
+        task_info = get_html_subtask_info(user, "/ui/", root_group)
+        auth_link = get_html_auth_link(user)
+        return HTMLResponse(
+            fstring_format(
+                _VIEW_TEMPLATE,
+                {
+                    "group_info": group_info,
+                    "task_info": task_info,
+                    "name": root_group.name,
+                    "description": root_group.description,
+                    "auth_link": auth_link,
+                },
+            )
+        )

zrb/runner/{web_controller → web_route}/home_page/view.html

@@ -29,4 +29,5 @@
                 {task_info}
         </main>
     </body>
+    <script src="/refresh-token.js"></script>
 </html>

zrb/runner/web_route/login_api_route.py

@@ -0,0 +1,31 @@
+from typing import TYPE_CHECKING, Annotated
+
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.cookie import set_auth_cookie
+from zrb.runner.web_util.token import generate_tokens_by_credentials
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_login_api(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import Depends, Response
+    from fastapi.responses import JSONResponse
+    from fastapi.security import OAuth2PasswordRequestForm
+
+    @app.post("/api/v1/login")
+    async def login_api(
+        response: Response, form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
+    ):
+        token = generate_tokens_by_credentials(
+            web_config=web_config,
+            username=form_data.username,
+            password=form_data.password,
+        )
+        if token is None:
+            return JSONResponse(
+                content={"detail": "Incorrect username or password"}, status_code=400
+            )
+        set_auth_cookie(web_config, response, token)
+        return token

zrb/runner/web_route/login_page/login_page_route.py

@@ -0,0 +1,39 @@
+import os
+from typing import TYPE_CHECKING
+
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.html import get_html_auth_link
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.util.file import read_file
+from zrb.util.string.format import fstring_format
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_login_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+
+    @app.get("/login", response_class=HTMLResponse, include_in_schema=False)
+    async def login(request: Request) -> HTMLResponse:
+        _DIR = os.path.dirname(__file__)
+        _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+        user = await get_user_from_request(web_config, request)
+        auth_link = get_html_auth_link(user)
+        return HTMLResponse(
+            fstring_format(
+                _VIEW_TEMPLATE,
+                {
+                    "name": root_group.name,
+                    "description": root_group.description,
+                    "auth_link": auth_link,
+                },
+            )
+        )

zrb/runner/{web_controller → web_route}/login_page/view.html

@@ -45,6 +45,7 @@
         </article>
     </main>
     <script src="/static/login/event.js"></script>
+    <script src="/refresh-token.js"></script>
 </body>
 
 </html>

zrb/runner/web_route/logout_api_route.py

@@ -0,0 +1,18 @@
+from typing import TYPE_CHECKING
+
+from zrb.runner.web_config.config import WebConfig
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_logout_api(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import Response
+
+    @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"}

zrb/runner/web_route/logout_page/logout_page_route.py

@@ -0,0 +1,40 @@
+import os
+from typing import TYPE_CHECKING
+
+from zrb.group.any_group import AnyGroup
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_util.html import get_html_auth_link
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.util.file import read_file
+from zrb.util.string.format import fstring_format
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_logout_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+
+    @app.get("/logout", response_class=HTMLResponse, include_in_schema=False)
+    async def logout(request: Request) -> HTMLResponse:
+        _DIR = os.path.dirname(__file__)
+        _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+        user = await get_user_from_request(web_config, request)
+        auth_link = get_html_auth_link(user)
+        return HTMLResponse(
+            fstring_format(
+                _VIEW_TEMPLATE,
+                {
+                    "name": root_group.name,
+                    "description": root_group.description,
+                    "auth_link": auth_link,
+                    "user": user,
+                },
+            )
+        )

zrb/runner/{web_controller → web_route}/logout_page/view.html

@@ -35,6 +35,7 @@
         </article>
     </main>
     <script src="/static/logout/event.js"></script>
+    <script src="/refresh-token.js"></script>
 </body>
 
 </html>

zrb/runner/{web_controller/group_info_page/controller.py → web_route/node_page/group/show_group_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 (
+from zrb.runner.web_schema.user import User
+from zrb.runner.web_util.html import (
     get_html_auth_link,
     get_html_subgroup_info,
     get_html_subtask_info,
@@ -11,7 +11,7 @@ from zrb.util.file import read_file
 from zrb.util.string.format import fstring_format
 
 
-def show_group_info_page(user: User, root_group: AnyGroup, group: AnyGroup, url: str):
+def show_group_page(user: User, root_group: AnyGroup, group: AnyGroup, url: str):
     from fastapi.responses import HTMLResponse
 
     _DIR = os.path.dirname(__file__)

zrb/runner/{web_controller/group_info_page → web_route/node_page/group}/view.html

@@ -33,4 +33,5 @@
                 {task_info}
         </main>
     </body>
+    <script src="/refresh-token.js"></script>
 </html>

zrb/runner/web_route/node_page/node_page_route.py

@@ -0,0 +1,50 @@
+import os
+from typing import TYPE_CHECKING
+
+from zrb.context.shared_context import SharedContext
+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_route.node_page.group.show_group_page import show_group_page
+from zrb.runner.web_route.node_page.task.show_task_page import show_task_page
+from zrb.runner.web_util.user import get_user_from_request
+from zrb.session.session import Session
+from zrb.task.any_task import AnyTask
+from zrb.util.group import NodeNotFoundError, extract_node_from_args
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_node_page(
+    app: "FastAPI",
+    root_group: AnyGroup,
+    web_config: WebConfig,
+) -> None:
+    from fastapi import Request
+    from fastapi.responses import HTMLResponse
+
+    @app.get("/ui/{path:path}", response_class=HTMLResponse, include_in_schema=False)
+    async def ui_page(path: str, request: Request) -> HTMLResponse:
+        user = await get_user_from_request(web_config, 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_task_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_page(user, root_group, node, url)
+        return show_error_page(user, root_group, 404, "Not found")

zrb/runner/{web_controller/session_page/controller.py → web_route/node_page/task/show_task_page.py}

@@ -2,15 +2,15 @@ import json
 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.session.any_session import AnySession
 from zrb.task.any_task import AnyTask
 from zrb.util.file import read_file
 from zrb.util.string.format import fstring_format
 
 
-def show_session_page(
+def show_task_page(
     user: User,
     root_group: AnyGroup,
     task: AnyTask,
@@ -33,11 +33,11 @@ def show_session_page(
     parent_url = "/".join(parent_url_parts)
     # Assemble session api url
     session_url_parts = list(url_parts)
-    session_url_parts[1] = "api/sessions"
+    session_url_parts[1] = "api/v1/task-sessions"
     session_api_url = "/".join(session_url_parts)
     # Assemble input api url
     input_url_parts = list(url_parts)
-    input_url_parts[1] = "api/inputs"
+    input_url_parts[1] = "api/v1/task-inputs"
     input_api_url = "/".join(input_url_parts)
     # Assemble ui url
     ui_url_parts = list(url_parts)

zrb/runner/{web_controller/session_page → web_route/node_page/task}/view.html

@@ -88,4 +88,5 @@
     <script src="/static/session/past-session.js"></script>
     <script src="/static/session/current-session.js"></script>
     <script src="/static/session/event.js"></script>
+    <script src="/refresh-token.js"></script>
 </html>

zrb/runner/web_route/refresh_token_api_route.py

@@ -0,0 +1,38 @@
+from typing import TYPE_CHECKING
+
+from zrb.runner.web_config.config import WebConfig
+from zrb.runner.web_schema.token import RefreshTokenRequest
+from zrb.runner.web_util.cookie import set_auth_cookie
+from zrb.runner.web_util.token import regenerate_tokens
+
+if TYPE_CHECKING:
+    # We want fastapi to only be loaded when necessary to decrease footprint
+    from fastapi import FastAPI
+
+
+def serve_refresh_token_api(app: "FastAPI", web_config: WebConfig) -> None:
+    from fastapi import Cookie, Response
+    from fastapi.responses import JSONResponse
+
+    @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:
+            return JSONResponse(
+                content={"detail": "Refresh token not provided"}, status_code=400
+            )
+        # Get token
+        new_token = regenerate_tokens(web_config, refresh_token)
+        set_auth_cookie(web_config, response, new_token)
+        return new_token

zrb/runner/web_route/static/refresh-token.template.js

@@ -0,0 +1,22 @@
+function refreshAuthToken(){
+    const refreshUrl = "/api/v1/refresh-token";
+    async function refresh() {
+        try {
+            const response = await fetch(refreshUrl, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                credentials: "include", // Include cookies in the request
+            });
+
+            if (!response.ok) {
+                throw new Error(`HTTP error! Status: ${response.status}`);
+            }
+            console.log("Token refreshed successfully");
+        } catch (error) {
+            console.error("Cannot refresh token", error)
+        }
+    }
+    setInterval(refresh, refreshIntervalSeconds * 1000);
+    refresh();
+}
+refreshAuthToken();

zrb/runner/{web_controller/static → web_route/static/resources}/session/current-session.js

@@ -1,5 +1,5 @@
 const CURRENT_SESSION = {
-    async pollCurrentSession() {
+    async startPolling() {
         const resultTextarea = document.getElementById("result-textarea");
         const logTextarea = document.getElementById("log-textarea");
         const submitTaskForm = document.getElementById("submit-task-form");

zrb/runner/{web_controller/static → web_route/static/resources}/session/event.js

@@ -1,7 +1,7 @@
 window.addEventListener("load", async function () {
     // Get current session
     if (cfg.SESSION_NAME != "") {
-        CURRENT_SESSION.pollCurrentSession();
+        CURRENT_SESSION.startPolling();
     }
     // set maxStartDate to today
     const tomorrow = new Date();
@@ -16,8 +16,6 @@ window.addEventListener("load", async function () {
     const formattedToday = UTIL.toLocalDateInputValue(today);
     const minStartAtInput = document.getElementById("min-start-at-input");
     minStartAtInput.value = formattedToday;
-    // Update session
-    PAST_SESSION.pollPastSession();
 });
 
 
@@ -63,11 +61,12 @@ submitTaskForm.addEventListener("input", async function(event) {
     } catch (error) {
         console.error("Error during fetch:", error);
     }
-})
+});
 
 
 function openPastSessionDialog(event) {
     event.preventDefault();
+    PAST_SESSION.startPolling();
     const dialog = document.getElementById("past-session-dialog")
     dialog.showModal();
 }
@@ -75,6 +74,7 @@ function openPastSessionDialog(event) {
 
 function closePastSessionDialog(event) {
     event.preventDefault();
+    PAST_SESSION.stopPolling();
     const dialog = document.getElementById("past-session-dialog")
     dialog.close();
 }
@@ -109,8 +109,7 @@ async function submitNewSessionForm(event) {
             const data = await response.json();
             cfg.SESSION_NAME = data.session_name;
             history.pushState(null, "", `${cfg.CURRENT_URL}${cfg.SESSION_NAME}`);
-            await PAST_SESSION.getAndRenderPastSession(0);
-            await CURRENT_SESSION.pollCurrentSession();
+            await CURRENT_SESSION.startPolling();
         } else {
             console.error("Error:", response);
         }