zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

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

@@ -1,12 +1,14 @@
-from sqlalchemy import Column, String, Text
-from core.repo import Repo, DBEntityMixin, DBRepo
-from module.log.schema.activity import (
-    Activity, ActivityData
-)
+from core.repo import DBEntityMixin, DBRepo, Repo
 from module.log.component import Base
+from module.log.schema.activity import Activity, ActivityData
+from sqlalchemy import Column, String, Text
 
 
 class DBEntityActivity(Base, DBEntityMixin):
+    class Config:
+        orm_mode = True
+        from_attributes = True
+
     __tablename__ = "activities"
     action = Column(String)
     entity: Column = Column(String)
@@ -17,8 +19,6 @@ class ActivityRepo(Repo[Activity, ActivityData]):
     pass
 
 
-class ActivityDBRepo(
-    DBRepo[Activity, ActivityData], ActivityRepo
-):
+class ActivityDBRepo(DBRepo[Activity, ActivityData], ActivityRepo):
     schema_cls = Activity
     db_entity_cls = DBEntityActivity

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

@@ -1,79 +1,62 @@
-from typing import Any, Mapping
 from logging import Logger
+from typing import Any, Mapping
+
 from core.messagebus import Publisher
-from core.rpc import Caller, Server
 from core.repo import SearchFilter
-from module.log.component.model.activity_model import (
-    activity_model
-)
-from module.log.schema.activity import ActivityData
+from core.rpc import Caller, Server
 from module.auth.schema.token import AccessTokenData
+from module.log.component.model.activity_model import activity_model
+from module.log.schema.activity import ActivityData
 
 
 def register_rpc(
-    logger: Logger,
-    rpc_server: Server,
-    rpc_caller: Caller,
-    publisher: Publisher
+    logger: Logger, rpc_server: Server, rpc_caller: Caller, publisher: Publisher
 ):
     logger.info('🥪 Register RPC handlers for "log.activity"')
 
-    @rpc_server.register('log_get_activity')
+    @rpc_server.register("log_get_activity")
     async def get(
         keyword: str,
         criterion: Mapping[str, Any],
         limit: int,
         offset: int,
-        user_token_data: Mapping[str, Any]
+        user_token_data: Mapping[str, Any],
     ) -> Mapping[str, Any]:
         result = await activity_model.get(
-            search_filter=SearchFilter(
-                keyword=keyword, criterion=criterion
-            ),
+            search_filter=SearchFilter(keyword=keyword, criterion=criterion),
             limit=limit,
-            offset=offset
+            offset=offset,
         )
-        return result.dict()
+        return result.model_dump()
 
-    @rpc_server.register('log_get_activity_by_id')
+    @rpc_server.register("log_get_activity_by_id")
     async def get_by_id(
-        id: str,
-        user_token_data: Mapping[str, Any] = {}
+        id: str, user_token_data: Mapping[str, Any] = {}
     ) -> Mapping[str, Any]:
         row = await activity_model.get_by_id(id)
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('log_insert_activity')
+    @rpc_server.register("log_insert_activity")
     async def insert(
-        data: Mapping[str, Any],
-        user_token_data: Mapping[str, Any]
+        data: Mapping[str, Any], user_token_data: Mapping[str, Any]
     ) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
-        data['created_by'] = user_token_data.user_id
-        data['updated_by'] = user_token_data.user_id
-        row = await activity_model.insert(
-            data=ActivityData(**data)
-        )
-        return row.dict()
+        data["created_by"] = user_token_data.user_id
+        data["updated_by"] = user_token_data.user_id
+        row = await activity_model.insert(data=ActivityData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('log_update_activity')
+    @rpc_server.register("log_update_activity")
     async def update(
-        id: str,
-        data: Mapping[str, Any],
-        user_token_data: Mapping[str, Any]
+        id: str, data: Mapping[str, Any], user_token_data: Mapping[str, Any]
     ) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
-        data['updated_by'] = user_token_data.user_id
-        row = await activity_model.update(
-            id=id, data=ActivityData(**data)
-        )
-        return row.dict()
+        data["updated_by"] = user_token_data.user_id
+        row = await activity_model.update(id=id, data=ActivityData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('log_delete_activity')
-    async def delete(
-        id: str,
-        user_token_data: Mapping[str, Any]
-    ) -> Mapping[str, Any]:
+    @rpc_server.register("log_delete_activity")
+    async def delete(id: str, user_token_data: Mapping[str, Any]) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
         row = await activity_model.delete(id=id)
-        return row.dict()
+        return row.model_dump()

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

@@ -1,7 +1,7 @@
-from sqlalchemy import Column, Integer, Table, ForeignKey
 from module.log.component.base import Base
+from sqlalchemy import Column, ForeignKey, Integer, Table
 
-'''
+"""
 You should put any "many-to-many" table declarations in this file.
 For example:
 ```
@@ -15,7 +15,7 @@ user_permission = Table(
 ```
 
 Remove the following assertions:
-'''
+"""
 assert Column
 assert Integer
 assert Table

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/event.py

@@ -1,16 +1,12 @@
 from logging import Logger
-from core.messagebus import Publisher, Consumer
+
+from core.messagebus import Consumer, Publisher
 from core.rpc import Caller
-from module.log.entity.activity.event import (
-    register_event as register_activity_event
-)
+from module.log.entity.activity.event import register_event as register_activity_event
 
 
 def register_event(
-    logger: Logger,
-    consumer: Consumer,
-    rpc_caller: Caller,
-    publisher: Publisher
+    logger: Logger, consumer: Consumer, rpc_caller: Caller, publisher: Publisher
 ):
     logger.info('🥪 Register event handlers for "log"')
     register_activity_event(logger, consumer, rpc_caller, publisher)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/migrate.py

@@ -1,8 +1,6 @@
-from config import (
-    app_enable_log_module
-)
-from component.log import logger
 from component.db_connection import engine
+from component.log import logger
+from config import app_enable_log_module
 from helper.migration import migrate
 from module.log.component import Base
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/register_module.py

@@ -1,11 +1,13 @@
-from config import (
-    app_enable_rpc_server, app_enable_event_handler, app_enable_api,
-    app_enable_log_module
-)
-from component.log import logger
 from component.app import app
+from component.log import logger
 from component.messagebus import consumer, publisher
 from component.rpc import rpc_caller, rpc_server
+from config import (
+    app_enable_api,
+    app_enable_event_handler,
+    app_enable_log_module,
+    app_enable_rpc_server,
+)
 from module.auth.component import authorizer
 from module.log.api import register_api
 from module.log.event import register_event
@@ -22,19 +24,16 @@ def register_log():
             app=app,
             authorizer=authorizer,
             rpc_caller=rpc_caller,
-            publisher=publisher
+            publisher=publisher,
         )
     if app_enable_event_handler:
         register_event(
-            logger=logger,
-            consumer=consumer,
-            rpc_caller=rpc_caller,
-            publisher=publisher
+            logger=logger, consumer=consumer, rpc_caller=rpc_caller, publisher=publisher
         )
     if app_enable_rpc_server:
         register_rpc(
             logger=logger,
             rpc_server=rpc_server,
             rpc_caller=rpc_caller,
-            publisher=publisher
+            publisher=publisher,
         )

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/rpc.py

@@ -1,15 +1,13 @@
-from typing import Any
 from logging import Logger
+from typing import Any
+
 from core.messagebus import Publisher
 from core.rpc import Caller, Server
 from module.log.entity.activity.rpc import register_rpc as register_activity_rpc
 
 
 def register_rpc(
-    logger: Logger,
-    rpc_server: Server,
-    rpc_caller: Caller,
-    publisher: Publisher
+    logger: Logger, rpc_server: Server, rpc_caller: Caller, publisher: Publisher
 ):
     logger.info('🥪 Register RPC handlers for "log"')
     register_activity_rpc(logger, rpc_server, rpc_caller, publisher)

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

@@ -1,5 +1,6 @@
 from typing import List
-from core.schema import BaseDateTimeSchema, BaseCountSchema
+
+from core.schema import BaseCountSchema, BaseDateTimeSchema
 
 
 class ActivityData(BaseDateTimeSchema):
@@ -13,6 +14,7 @@ class Activity(ActivityData):
 
     class Config:
         orm_mode = True
+        from_attributes = True
 
 
 class ActivityResult(BaseCountSchema):

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/requirements.txt

@@ -1,17 +1,17 @@
-SQLAlchemy==2.0.18
-aiormq==6.7.7
-aiokafka==0.8.1
-alembic==1.11.3
-bcrypt==4.0.1
-fastapi==0.101.1
+SQLAlchemy==2.0.25
+aiormq==6.8.0
+aiokafka==0.10.0
+alembic==1.13.1
+bcrypt==4.1.2
+fastapi==0.109.0
 jsons==1.6.3
-pydantic==1.10.9
-psycopg2-binary==2.9.6
+pydantic==2.5.3
+psycopg2-binary==2.9.9
 python-jose==3.3.0
-uvicorn==0.22.0
-watchfiles==0.19.0
+uvicorn==0.27.0
+watchfiles==0.21.0
 python-multipart==0.0.6
-python-ulid==1.1.0
+python-ulid==2.2.0
 opentelemetry-distro==0.40b0
 opentelemetry-exporter-otlp==1.19.0
 opentelemetry-instrumentation-fastapi==0.40b0
@@ -21,4 +21,4 @@ pytest==7.4.0
 pytest-cov==4.1.0
 pytest-asyncio==0.21.0
 httpx==0.24.1
-asgi-lifespan==2.1.0
+asgi-lifespan==2.1.0

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/test/auth/test_group_crud.py

@@ -1,236 +1,206 @@
 from typing import AsyncIterator
-from httpx import AsyncClient
-from src.config import app_auth_admin_username, app_auth_admin_password
+
 import pytest
+from httpx import AsyncClient
+from src.config import app_auth_admin_password, app_auth_admin_username
 
 inserted_success_data = {
-    'name': 'test-create-group-success',
-    'description': '',
-    'permissions': [],
+    "name": "test-create-group-success",
+    "description": "",
+    "permissions": [],
 }
 to_be_updated_success_data = {
-    'name': 'test-group-to-be-updated-success',
-    'description': '',
-    'permissions': [],
+    "name": "test-group-to-be-updated-success",
+    "description": "",
+    "permissions": [],
 }
 updated_success_data = {
-    'name': 'test-group-updated-success',
-    'description': 'new-description',
-    'permissions': [],
+    "name": "test-group-updated-success",
+    "description": "new-description",
+    "permissions": [],
 }
 to_be_deleted_success_data = {
-    'name': 'test-group-to-be-deleted-success',
-    'description': '',
-    'permissions': [],
+    "name": "test-group-to-be-deleted-success",
+    "description": "",
+    "permissions": [],
 }
 
 
 @pytest.mark.asyncio
 async def test_insert_group_and_get_success(
-    test_client_generator: AsyncIterator[AsyncClient]
+    test_client_generator: AsyncIterator[AsyncClient],
 ):
     async for client in test_client_generator:
         # login
         login_admin_response = await client.post(
-            '/api/v1/auth/login',
+            "/api/v1/auth/login",
             json={
-                'identity': app_auth_admin_username,
-                'password': app_auth_admin_password
-            }
+                "identity": app_auth_admin_username,
+                "password": app_auth_admin_password,
+            },
         )
         assert login_admin_response.status_code == 200
-        admin_access_token = login_admin_response.json().get(
-            'access_token', ''
-        )
+        admin_access_token = login_admin_response.json().get("access_token", "")
 
         # create group
         create_response = await client.post(
-            '/api/v1/auth/groups',
+            "/api/v1/auth/groups",
             json=inserted_success_data,
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert create_response.status_code == 200
         json_create_response = create_response.json()
-        create_response_id = json_create_response.get('id', '')
-        assert create_response_id != ''
+        create_response_id = json_create_response.get("id", "")
+        assert create_response_id != ""
 
         # get_by_id
         get_by_id_response = await client.get(
-            f'/api/v1/auth/groups/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/auth/groups/{create_response_id}",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert get_by_id_response.status_code == 200
         json_get_by_id_response = get_by_id_response.json()
-        get_by_id_response_id = json_get_by_id_response.get('id', '')
+        get_by_id_response_id = json_get_by_id_response.get("id", "")
         assert get_by_id_response_id == create_response_id
 
         # get
         get_response = await client.get(
-            '/api/v1/auth/groups',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            "/api/v1/auth/groups",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert get_response.status_code == 200
         json_get_response = get_response.json()
-        get_response_count = json_get_response.get('count', '')
+        get_response_count = json_get_response.get("count", "")
         assert get_response_count > 0
-        get_response_data = json_get_response.get('data', [])
+        get_response_data = json_get_response.get("data", [])
         get_created_response_data = [
-            row for row in get_response_data
-            if row['id'] == create_response_id
+            row for row in get_response_data if row["id"] == create_response_id
         ]
         assert len(get_created_response_data) == 1
 
 
 @pytest.mark.asyncio
 async def test_update_group_and_get_success(
-    test_client_generator: AsyncIterator[AsyncClient]
+    test_client_generator: AsyncIterator[AsyncClient],
 ):
     async for client in test_client_generator:
         # login
         login_admin_response = await client.post(
-            '/api/v1/auth/login',
+            "/api/v1/auth/login",
             json={
-                'identity': app_auth_admin_username,
-                'password': app_auth_admin_password,
-            }
+                "identity": app_auth_admin_username,
+                "password": app_auth_admin_password,
+            },
         )
         assert login_admin_response.status_code == 200
-        admin_access_token = login_admin_response.json().get(
-            'access_token', ''
-        )
+        admin_access_token = login_admin_response.json().get("access_token", "")
 
         # create group
         create_response = await client.post(
-            '/api/v1/auth/groups',
+            "/api/v1/auth/groups",
             json=to_be_updated_success_data,
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert create_response.status_code == 200
         json_create_response = create_response.json()
-        create_response_id = json_create_response.get('id', '')
-        assert create_response_id != ''
+        create_response_id = json_create_response.get("id", "")
+        assert create_response_id != ""
 
         # update group
         update_response = await client.put(
-            f'/api/v1/auth/groups/{create_response_id}',
+            f"/api/v1/auth/groups/{create_response_id}",
             json=updated_success_data,
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert update_response.status_code == 200
         json_update_response = update_response.json()
-        update_response_id = json_update_response.get('id', '')
+        update_response_id = json_update_response.get("id", "")
         assert update_response_id == create_response_id
 
         # get_by_id
         get_by_id_response = await client.get(
-            f'/api/v1/auth/groups/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/auth/groups/{create_response_id}",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert get_by_id_response.status_code == 200
         json_get_by_id_response = get_by_id_response.json()
-        get_by_id_response_id = json_get_by_id_response.get('id', '')
+        get_by_id_response_id = json_get_by_id_response.get("id", "")
         assert get_by_id_response_id == create_response_id
         for key, expected_value in updated_success_data.items():
-            actual_value = json_get_by_id_response.get(key, '')
-            assert f'{key}:{actual_value}' == f'{key}:{expected_value}'
+            actual_value = json_get_by_id_response.get(key, "")
+            assert f"{key}:{actual_value}" == f"{key}:{expected_value}"
 
         # get
         get_response = await client.get(
-            '/api/v1/auth/groups',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            "/api/v1/auth/groups",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert get_response.status_code == 200
         json_get_response = get_response.json()
-        get_response_count = json_get_response.get('count', '')
+        get_response_count = json_get_response.get("count", "")
         assert get_response_count > 0
-        get_response_data = json_get_response.get('data', [])
+        get_response_data = json_get_response.get("data", [])
         get_created_response_data = [
-            row for row in get_response_data
-            if row['id'] == create_response_id
+            row for row in get_response_data if row["id"] == create_response_id
         ]
         assert len(get_created_response_data) == 1
 
 
 @pytest.mark.asyncio
 async def test_delete_group_and_get_success(
-    test_client_generator: AsyncIterator[AsyncClient]
+    test_client_generator: AsyncIterator[AsyncClient],
 ):
     async for client in test_client_generator:
         # login
         login_admin_response = await client.post(
-            '/api/v1/auth/login',
+            "/api/v1/auth/login",
             json={
-                'identity': app_auth_admin_username,
-                'password': app_auth_admin_password
-            }
+                "identity": app_auth_admin_username,
+                "password": app_auth_admin_password,
+            },
         )
         assert login_admin_response.status_code == 200
-        admin_access_token = login_admin_response.json().get(
-            'access_token', ''
-        )
+        admin_access_token = login_admin_response.json().get("access_token", "")
 
         # create group
         create_response = await client.post(
-            '/api/v1/auth/groups',
+            "/api/v1/auth/groups",
             json=to_be_deleted_success_data,
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert create_response.status_code == 200
         json_create_response = create_response.json()
-        create_response_id = json_create_response.get('id', '')
-        assert create_response_id != ''
+        create_response_id = json_create_response.get("id", "")
+        assert create_response_id != ""
 
         # create group
         delete_response = await client.delete(
-            f'/api/v1/auth/groups/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/auth/groups/{create_response_id}",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert delete_response.status_code == 200
         json_delete_response = delete_response.json()
-        delete_response_id = json_delete_response.get('id', '')
+        delete_response_id = json_delete_response.get("id", "")
         assert delete_response_id == create_response_id
 
         # get_by_id
         get_by_id_response = await client.get(
-            f'/api/v1/auth/groups/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/auth/groups/{create_response_id}",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert get_by_id_response.status_code == 404
 
         # get
         get_response = await client.get(
-            '/api/v1/auth/groups',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            "/api/v1/auth/groups",
+            headers={"Authorization": "Bearer " + admin_access_token},
         )
         assert get_response.status_code == 200
         json_get_response = get_response.json()
-        get_response_count = json_get_response.get('count', '')
+        get_response_count = json_get_response.get("count", "")
         assert get_response_count > 0
-        get_response_data = json_get_response.get('data', [])
+        get_response_data = json_get_response.get("data", [])
         get_created_response_data = [
-            row for row in get_response_data
-            if row['id'] == create_response_id
+            row for row in get_response_data if row["id"] == create_response_id
         ]
         assert len(get_created_response_data) == 0