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

zrb/runner/web_app.py

@@ -1,30 +1,57 @@
 import asyncio
+import json
 import os
 import sys
-from datetime import datetime, timedelta
-from typing import Any
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Annotated
 
-from zrb.config import BANNER, WEB_HTTP_PORT
+from zrb.config import BANNER, VERSION
 from zrb.context.shared_context import SharedContext
 from zrb.group.any_group import AnyGroup
-from zrb.runner.web_controller.group_info_ui.controller import handle_group_info_ui
-from zrb.runner.web_controller.home_page.controller import handle_home_page
-from zrb.runner.web_controller.task_ui.controller import handle_task_ui
-from zrb.runner.web_util import NewSessionResponse
+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.session_state_logger.default_session_state_logger import (
-    default_session_state_logger,
-)
+from zrb.session_state_logger.any_session_state_logger import AnySessionStateLogger
 from zrb.task.any_task import AnyTask
-from zrb.util.group import extract_node_from_args, get_node_path
+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(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
+def create_app(
+    root_group: AnyGroup,
+    web_config: WebConfig,
+    session_state_logger: AnySessionStateLogger,
+) -> "FastAPI":
     from contextlib import asynccontextmanager
 
-    from fastapi import FastAPI, HTTPException, Query, Request
-    from fastapi.responses import FileResponse, HTMLResponse
+    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
 
     _STATIC_DIR = os.path.join(os.path.dirname(__file__), "web_controller", "static")
@@ -33,7 +60,7 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
     @asynccontextmanager
     async def lifespan(app: FastAPI):
         for line in BANNER.split("\n") + [
-            f"Zrb Server running on http://localhost:{port}"
+            f"Zrb Server running on http://localhost:{web_config.port}"
         ]:
             print(line, file=sys.stderr)
         yield
@@ -41,17 +68,16 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
             coro.cancel()
         asyncio.gather(*_COROS)
 
-    app = FastAPI(title="zrb", lifespan=lifespan)
-
-    # Serve static files
+    app = FastAPI(
+        title="Zrb",
+        version=VERSION,
+        summary="Your Automation Powerhouse",
+        lifespan=lifespan,
+        docs_url=None,
+    )
     app.mount("/static", StaticFiles(directory=_STATIC_DIR), name="static")
 
-    @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():
-        return handle_home_page(root_group)
-
+    # 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)
@@ -59,62 +85,198 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
             return FileResponse(full_path)
         raise HTTPException(status_code=404, detail="File not found")
 
-    @app.get("/ui/{path:path}", include_in_schema=False)
-    async def ui_page(path: str):
+    @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:
-            raise HTTPException(status_code=404, detail="Not Found")
+            return show_error_page(user, root_group, 422, "Undefined path")
         args = path.strip("/").split("/")
-        node, node_path, residual_args = extract_node_from_args(root_group, args)
+        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 handle_task_ui(root_group, node, session, url, residual_args)
+            return show_session_page(
+                user, root_group, node, session, url, residual_args
+            )
         elif isinstance(node, AnyGroup):
-            return handle_group_info_ui(root_group, node, url)
-        raise HTTPException(status_code=404, detail="Not Found")
+            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/sessions/{path:path}")
-    async def create_new_session(
-        path: str, request: Request = None
+    @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("/")
-        node, _, residual_args = extract_node_from_args(root_group, args)
-        if isinstance(node, AnyTask):
+        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(node.async_run(session, str_kwargs=body))
+                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/sessions/{path:path}",
+        "/api/v1/task-sessions/{path:path}",
         response_model=SessionStateLog | SessionStateLogList,
     )
-    async def get_session(
+    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("/")
-        node, _, residual_args = extract_node_from_args(root_group, args)
-        if isinstance(node, AnyTask) and residual_args:
+        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, node)
+                task_path = get_node_path(root_group, task)
                 max_start_time = (
                     datetime.now()
                     if max_start_query is None
@@ -125,14 +287,14 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
                     if min_start_query is None
                     else datetime.strptime(min_start_query, "%Y-%m-%d %H:%M:%S")
                 )
-                return list_sessions(
+                return _get_existing_sessions(
                     task_path, min_start_time, max_start_time, page, limit
                 )
             else:
-                return read_session(residual_args[0])
+                return _read_session(residual_args[0])
         raise HTTPException(status_code=404, detail="Not Found")
 
-    def list_sessions(
+    def _get_existing_sessions(
         task_path: list[str],
         min_start_time: datetime,
         max_start_time: datetime,
@@ -140,7 +302,7 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
         limit: int,
     ) -> SessionStateLogList:
         try:
-            return default_session_state_logger.list(
+            return session_state_logger.list(
                 task_path,
                 min_start_time=min_start_time,
                 max_start_time=max_start_time,
@@ -150,9 +312,9 @@ def create_app(root_group: AnyGroup, port: int = WEB_HTTP_PORT):
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
 
-    def read_session(session_name: str) -> SessionStateLog:
+    def _read_session(session_name: str) -> SessionStateLog:
         try:
-            return default_session_state_logger.read(session_name)
+            return session_state_logger.read(session_name)
         except Exception as e:
             raise HTTPException(status_code=500, detail=str(e))
 

zrb/runner/web_config.py

@@ -0,0 +1,274 @@
+from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Callable
+
+from pydantic import BaseModel, ConfigDict
+
+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.group.any_group import AnyGroup
+from zrb.task.any_task import AnyTask
+from zrb.util.group import get_all_subtasks
+
+if TYPE_CHECKING:
+    # Import Request only for type checking to reduce runtime dependencies
+    from fastapi import Request
+
+
+class NewSessionResponse(BaseModel):
+    session_name: str
+
+
+class RefreshTokenRequest(BaseModel):
+    refresh_token: str
+
+
+class User(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    username: str
+    password: str = ""
+    is_super_admin: bool = False
+    is_guest: bool = False
+    accessible_tasks: list[AnyTask | str] = []
+
+    def is_password_match(self, password: str) -> bool:
+        return self.password == password
+
+    def can_access_group(self, group: AnyGroup) -> bool:
+        if self.is_super_admin:
+            return True
+        all_tasks = get_all_subtasks(group, web_only=True)
+        if any(self.can_access_task(task) for task in all_tasks):
+            return True
+        return False
+
+    def can_access_task(self, task: AnyTask) -> bool:
+        if self.is_super_admin:
+            return True
+        if task.name in self.accessible_tasks or task in self.accessible_tasks:
+            return True
+        return False
+
+
+class Token(BaseModel):
+    access_token: str
+    refresh_token: str
+    token_type: str
+
+
+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
+
+    async def get_user_from_request(self, request: "Request") -> User | None:
+        from fastapi.security import OAuth2PasswordBearer
+
+        if not self.enable_auth:
+            return self.default_user
+        # Normally we use "Depends"
+        get_bearer_token = OAuth2PasswordBearer(
+            tokenUrl="/api/v1/login", auto_error=False
+        )
+        bearer_token = await get_bearer_token(request)
+        token_user = self._get_user_from_token(bearer_token)
+        if token_user is not None:
+            return token_user
+        cookie_user = self._get_user_from_cookie(request)
+        if cookie_user is not None:
+            return cookie_user
+        return self.default_user
+
+    def _get_user_from_token(self, token: str) -> User | None:
+        try:
+            from jose import jwt
+
+            payload = jwt.decode(
+                token,
+                self.secret_key,
+                options={"require_sub": True, "require_exp": True},
+            )
+            username: str = payload.get("sub")
+            if username is None:
+                return None
+            user = self.find_user_by_username(username)
+            if user is None:
+                return None
+            return user
+        except Exception:
+            return None
+
+    def _get_user_from_cookie(self, request: "Request") -> User | None:
+        token = request.cookies.get(self.access_token_cookie_name)
+        if token:
+            return self._get_user_from_token(token)
+        return None
+
+    def get_user_by_credentials(self, username: str, password: str) -> User | None:
+        user = self.find_user_by_username(username)
+        if user is None or not user.is_password_match(password):
+            return None
+        return user
+
+    def generate_tokens_by_credentials(
+        self, username: str, password: str
+    ) -> Token | None:
+        if not self.enable_auth:
+            user = self.default_user
+        else:
+            user = self.get_user_by_credentials(username, password)
+        if user is None:
+            return None
+        access_token = self._generate_access_token(user.username)
+        refresh_token = self._generate_refresh_token(user.username)
+        return Token(
+            access_token=access_token, refresh_token=refresh_token, token_type="bearer"
+        )
+
+    def _generate_access_token(self, username: str) -> str:
+        from jose import jwt
+
+        expire = datetime.now() + timedelta(minutes=self.access_token_expire_minutes)
+        to_encode = {"sub": username, "exp": expire, "type": "access"}
+        return jwt.encode(to_encode, self.secret_key)
+
+    def _generate_refresh_token(self, username: str) -> str:
+        from jose import jwt
+
+        expire = datetime.now() + timedelta(minutes=self.refresh_token_expire_minutes)
+        to_encode = {"sub": username, "exp": expire, "type": "refresh"}
+        return jwt.encode(to_encode, self.secret_key)
+
+    def regenerate_tokens(self, refresh_token: str) -> Token:
+        from fastapi import HTTPException
+        from jose import jwt
+
+        # Decode and validate token
+        try:
+            payload = jwt.decode(
+                refresh_token,
+                self.secret_key,
+                options={"require_exp": True, "require_sub": True},
+            )
+        except Exception:
+            raise HTTPException(status_code=401, detail="Invalid JWT token")
+        if payload.get("type") != "refresh":
+            raise HTTPException(status_code=401, detail="Invalid token type")
+        username: str = payload.get("sub")
+        if username is None:
+            raise HTTPException(status_code=401, detail="Invalid refresh token")
+        user = self.find_user_by_username(username)
+        if user is None:
+            raise HTTPException(status_code=401, detail="User not found")
+        # Create new token
+        new_access_token = self._generate_access_token(username)
+        new_refresh_token = self._generate_refresh_token(username)
+        return Token(
+            access_token=new_access_token,
+            refresh_token=new_refresh_token,
+            token_type="bearer",
+        )
+
+
+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_controller/error_page/controller.py

@@ -0,0 +1,27 @@
+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.util.file import read_file
+from zrb.util.string.format import fstring_format
+
+
+def show_error_page(user: User, root_group: AnyGroup, status_code: int, message: str):
+    from fastapi.responses import HTMLResponse
+
+    _DIR = os.path.dirname(__file__)
+    _VIEW_TEMPLATE = read_file(os.path.join(_DIR, "view.html"))
+    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,
+                "error_status_code": status_code,
+                "error_message": message,
+            },
+        )
+    )