zrb 0.9.2__tar.gz → 0.10.0__tar.gz

{zrb-0.9.2 → zrb-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zrb
-Version: 0.9.2
+Version: 0.10.0
 Summary: A Framework to Enhance Your Workflow
 Home-page: https://github.com/state-alchemists/zrb
 License: AGPL-3.0-or-later

{zrb-0.9.2 → zrb-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "zrb"
-version = "0.9.2"
+version = "0.10.0"
 description = "A Framework to Enhance Your Workflow"
 authors = ["Go Frendi Gunawan <gofrendiasgard@gmail.com>"]
 license = "AGPL-3.0-or-later"
@@ -27,7 +27,7 @@ croniter = "~2.0.2"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~7.0.0"
-black = "~24.2.0"
+black = "~24.3.0"
 isort = "~5.13.2"
 tomli = "~2.0.1"
 pytest = "~7.4.0"

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/__init__.py

@@ -28,6 +28,7 @@ from zrb.task.resource_maker import Replacement, ReplacementMutator, ResourceMak
 from zrb.task.rsync_task import RsyncTask
 from zrb.task.task import Task
 from zrb.task.time_watcher import TimeWatcher
+from zrb.task.wiki_task import create_wiki_tasks
 from zrb.task_env.env import Env
 from zrb.task_env.env_file import EnvFile
 from zrb.task_group.group import Group
@@ -40,6 +41,7 @@ from zrb.task_input.password_input import PasswordInput
 from zrb.task_input.str_input import StrInput
 from zrb.task_input.task_input import Input
 
+assert create_wiki_tasks
 assert runner
 assert AnyTask
 assert OnTriggered

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/docker_compose_task/template/src/kebab-zrb-task-name/image/Dockerfile

@@ -1,6 +1,7 @@
 FROM python:3.10-slim
 ENV APP_MESSAGE "Hello, world!"
 ENV APP_PORT 8080
+ENV POETRY_VIRTUAL_ENVS_CREATE=false
 WORKDIR /home
 COPY ./pyproject.toml ./pyproject.toml
 RUN pip install "poetry==1.7.1"

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/docker_compose_task/template/src/kebab-zrb-task-name/image/pyproject.toml

@@ -13,7 +13,7 @@ uvicorn = "==0.20.0"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~7.0.0"
-black = "~24.2.0"
+black = "~24.3.0"
 isort = "~5.13.2"
 pytest = "~7.4.0"
 pytest-cov = "~4.1.0"

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/fastapp/add.py

@@ -85,11 +85,23 @@ copy_resource = ResourceMaker(
     excludes=[
         "*/__pycache__",
         "*/deployment/venv",
-        "*/src/kebab-app-name/.venv",
-        "*/src/kebab-app-name/src/frontend/node_modules",
-        "*/src/kebab-app-name/src/frontend/build",
-        "*/src/kebab-app-name/src/frontend/.svelte-kit",
-        "*/src/kebab-app-name/monitoring/clickhouse",
+        "*/src/kebab-zrb-app-name/.venv",
+        "*/src/kebab-zrb-app-name/src/frontend/node_modules",
+        "*/src/kebab-zrb-app-name/src/frontend/build",
+        "*/src/kebab-zrb-app-name/src/frontend/.svelte-kit",
+    ],
+    skip_parsing=[
+        "*.mp3",
+        "*.pdf",
+        "*.exe",
+        "*.dll",
+        "*.bin",
+        "*.iso",
+        "*.png",
+        "*.jpg",
+        "*.gif",
+        "*.ico",
+        "*/monitoring/clickhouse/user_scripts/histogramQuantile",
     ],
 )
 

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/loadtest/pyproject.toml

@@ -13,7 +13,7 @@ locust = "==2.16.1"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~6.0.0"
-black = "~23.12.1"
+black = "~24.3.0"
 isort = "~5.13.2"
 
 [build-system]

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/Dockerfile

@@ -8,6 +8,7 @@ RUN npm install --save-dev && npm run build
 FROM python:3.10-slim
 ENV APP_HOST 0.0.0.0
 ENV APP_PORT 8080
+ENV POETRY_VIRTUAL_ENVS_CREATE=false
 WORKDIR /home
 RUN apt update && apt install curl psmisc -y
 RUN pip install -U pip

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/config.py

@@ -14,7 +14,9 @@ app_reload = str_to_boolean(os.getenv("APP_RELOAD", "true"))
 app_max_not_ready = int(os.getenv("APP_MAX_NOT_READY", "10"))
 
 app_enable_otel = str_to_boolean(os.getenv("APP_ENABLE_OTEL", "false"))
-app_otel_exporter_otlp_endpoint = os.getenv("APP_OTEL_EXPORTER_OTLP_ENDPOINT", "false")
+app_otel_exporter_otlp_endpoint = os.getenv(
+    "APP_OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"
+)
 
 app_auth_access_token_cookie_key = os.getenv(
     "PUBLIC_AUTH_ACCESS_TOKEN_COOKIE_KEY", "access_token"

zrb-0.10.0/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/group/api.py

@@ -0,0 +1,132 @@
+from logging import Logger
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme
+from module.auth.schema.group import Group, GroupData, GroupResult
+from module.auth.schema.token import AccessTokenData
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "auth.group"')
+
+    @app.get("/api/v1/auth/groups", response_model=GroupResult)
+    async def get_groups(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_group",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return GroupResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get("/api/v1/auth/groups/{id}", response_model=Group)
+    async def get_group_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_group_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_group_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/groups", response_model=Group)
+    async def insert_group(
+        data: GroupData, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_insert_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_group",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.put("/api/v1/auth/groups/{id}", response_model=Group)
+    async def update_group(
+        id: str,
+        data: GroupData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_update_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_group",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.delete("/api/v1/auth/groups/{id}", response_model=Group)
+    async def delete_group(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:group:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_delete_group"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_group",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Group(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)

zrb-0.10.0/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/permission/api.py

@@ -0,0 +1,133 @@
+from logging import Logger
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme
+from module.auth.schema.permission import Permission, PermissionData, PermissionResult
+from module.auth.schema.token import AccessTokenData
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "auth.permission"')
+
+    @app.get("/api/v1/auth/permissions", response_model=PermissionResult)
+    async def get_permissions(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_permission",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return PermissionResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get("/api/v1/auth/permissions/{id}", response_model=Permission)
+    async def get_permission_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_permission_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_permission_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/permissions", response_model=Permission)
+    async def insert_permission(
+        data: PermissionData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_insert_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_permission",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.put("/api/v1/auth/permissions/{id}", response_model=Permission)
+    async def update_permission(
+        id: str,
+        data: PermissionData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_update_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_permission",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.delete("/api/v1/auth/permissions/{id}", response_model=Permission)
+    async def delete_permission(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:permission:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_delete_permission"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_permission",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Permission(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)

zrb-0.10.0/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/user/api.py

@@ -0,0 +1,197 @@
+from logging import Logger
+from typing import Annotated, List, Mapping
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from fastapi.security import OAuth2PasswordRequestForm
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme, bearer_token_scheme
+from module.auth.schema.request import IsAuthorizedRequest, RefreshTokenRequest
+from module.auth.schema.token import AccessTokenData, TokenResponse
+from module.auth.schema.user import User, UserData, UserLogin, UserResult
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_auth_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register Login API for "auth.user"')
+
+    @app.post("/api/v1/auth/login-oauth", response_model=TokenResponse)
+    async def login_oauth(
+        form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
+    ) -> TokenResponse:
+        data = UserLogin(identity=form_data.username, password=form_data.password)
+        return await _create_token(data=data)
+
+    @app.post("/api/v1/auth/login", response_model=TokenResponse)
+    async def login(data: UserLogin) -> TokenResponse:
+        return await _create_token(data=data)
+
+    async def _create_token(data: UserLogin) -> TokenResponse:
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_create_token"):
+                token_response_dict = await rpc_caller.call(
+                    "auth_create_token", login_data=data.model_dump()
+                )
+                return TokenResponse(**token_response_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/refresh-token", response_model=TokenResponse)
+    async def refresh_token(
+        data: RefreshTokenRequest, refresh_token: str = Depends(bearer_token_scheme)
+    ) -> TokenResponse:
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_refresh_token"):
+                token_response_dict = await rpc_caller.call(
+                    "auth_refresh_token",
+                    refresh_token=refresh_token,
+                    access_token=data.access_token,
+                )
+                return TokenResponse(**token_response_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/is-authorized", response_model=Mapping[str, bool])
+    async def is_authorized(
+        data: IsAuthorizedRequest,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ) -> Mapping[str, str]:
+        try:
+            user_id = user_token_data.user_id
+            with tracer.start_as_current_span("auth.rpc.auth_is_user_authorized"):
+                return await rpc_caller.call(
+                    "auth_is_user_authorized",
+                    id=user_id,
+                    permission_name=data.permission_names,
+                )
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "auth.user"')
+
+    @app.get("/api/v1/auth/users", response_model=UserResult)
+    async def get_users(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_user",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return UserResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get("/api/v1/auth/users/{id}", response_model=User)
+    async def get_user_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_get_user_by_id"):
+                result_dict = await rpc_caller.call(
+                    "auth_get_user_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.post("/api/v1/auth/users", response_model=User)
+    async def insert_user(
+        data: UserData, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:insert"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_insert_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_insert_user",
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.put("/api/v1/auth/users/{id}", response_model=User)
+    async def update_user(
+        id: str,
+        data: UserData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:update"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_update_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_update_user",
+                    id=id,
+                    data=data.model_dump(),
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.delete("/api/v1/auth/users/{id}", response_model=User)
+    async def delete_user(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "auth:user:delete"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("auth.rpc.auth_delete_user"):
+                result_dict = await rpc_caller.call(
+                    "auth_delete_user",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return User(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)

zrb-0.10.0/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/entity/activity/api.py

@@ -0,0 +1,69 @@
+from logging import Logger
+
+from component.error import HTTPAPIException
+from component.messagebus import Publisher
+from component.rpc import Caller
+from fastapi import Depends, FastAPI
+from module.auth.component import Authorizer
+from module.auth.integration import access_token_scheme
+from module.auth.schema.token import AccessTokenData
+from module.log.schema.activity import Activity, ActivityResult
+from opentelemetry import trace
+
+tracer = trace.get_tracer(__name__)
+
+
+def register_api(
+    logger: Logger,
+    app: FastAPI,
+    authorizer: Authorizer,
+    rpc_caller: Caller,
+    publisher: Publisher,
+):
+    logger.info('🥪 Register API for "log.activity"')
+
+    @app.get("/api/v1/log/activities", response_model=ActivityResult)
+    async def get_activitys(
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "log:activity:get"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("log.rpc.log_get_activity"):
+                result_dict = await rpc_caller.call(
+                    "log_get_activity",
+                    keyword=keyword,
+                    criterion={},
+                    limit=limit,
+                    offset=offset,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return ActivityResult(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)
+
+    @app.get("/api/v1/log/activities/{id}", response_model=Activity)
+    async def get_activity_by_id(
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
+    ):
+        with tracer.start_as_current_span("authorizer.is_having_permission"):
+            if not await authorizer.is_having_permission(
+                user_token_data.user_id, "log:activity:get_by_id"
+            ):
+                raise HTTPAPIException(403, "Unauthorized")
+        try:
+            with tracer.start_as_current_span("log.rpc.log_get_activity_by_id"):
+                result_dict = await rpc_caller.call(
+                    "log_get_activity_by_id",
+                    id=id,
+                    user_token_data=user_token_data.model_dump(),
+                )
+                return Activity(**result_dict)
+        except Exception as e:
+            raise HTTPAPIException(error=e)

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/entity/activity/event.py

@@ -13,7 +13,5 @@ def register_event(
     logger.info('🥪 Register event handlers for "log.activity"')
 
     @consumer.register("log_new_activity")
-    async def insert(
-        data: Mapping[str, Any],
-    ):
+    async def insert(data: Mapping[str, Any]):
         await activity_model.insert(data=ActivityData(**data))

{zrb-0.9.2 → zrb-0.10.0}/src/zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/pyproject.toml

@@ -30,7 +30,7 @@ opentelemetry-instrumentation-fastapi= "==0.44b0"
 
 [tool.poetry.dev-dependencies]
 flake8 = "~7.0.0"
-black = "~24.2.0"
+black = "~24.3.0"
 isort = "~5.13.2"
 pytest = "~7.4.0"
 pytest-cov = "~4.1.0"