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

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/entity/snake_zrb_entity_name/model.py

@@ -1,11 +1,15 @@
 from module.log.core.historical_repo_model import HistoricalRepoModel
 from module.snake_zrb_module_name.schema.snake_zrb_entity_name import (
-    PascalZrbEntityName, PascalZrbEntityNameData, PascalZrbEntityNameResult
+    PascalZrbEntityName,
+    PascalZrbEntityNameData,
+    PascalZrbEntityNameResult,
 )
 
 
 class PascalZrbEntityNameModel(
-    HistoricalRepoModel[PascalZrbEntityName, PascalZrbEntityNameData, PascalZrbEntityNameResult]
+    HistoricalRepoModel[
+        PascalZrbEntityName, PascalZrbEntityNameData, PascalZrbEntityNameResult
+    ]
 ):
     schema_result_cls = PascalZrbEntityNameResult
-    log_entity_name = 'snake_zrb_entity_name'
+    log_entity_name = "snake_zrb_entity_name"

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/entity/snake_zrb_entity_name/repo.py

@@ -1,12 +1,17 @@
-from sqlalchemy import Column, String
-from core.repo import Repo, DBEntityMixin, DBRepo
+from core.repo import DBEntityMixin, DBRepo, Repo
+from module.snake_zrb_module_name.component import Base
 from module.snake_zrb_module_name.schema.snake_zrb_entity_name import (
-    PascalZrbEntityName, PascalZrbEntityNameData
+    PascalZrbEntityName,
+    PascalZrbEntityNameData,
 )
-from module.snake_zrb_module_name.component import Base
+from sqlalchemy import Column, String
 
 
 class DBEntityPascalZrbEntityName(Base, DBEntityMixin):
+    class Config:
+        orm_mode = True
+        from_attributes = True
+
     __tablename__ = "snake_zrb_plural_entity_name"
     snake_zrb_column_name = Column(String)
 

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/entity/snake_zrb_entity_name/rpc.py

@@ -1,79 +1,72 @@
-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 core.rpc import Caller, Server
+from module.auth.schema.token import AccessTokenData
 from module.snake_zrb_module_name.component.model.snake_zrb_entity_name_model import (
-    snake_zrb_entity_name_model
+    snake_zrb_entity_name_model,
+)
+from module.snake_zrb_module_name.schema.snake_zrb_entity_name import (
+    PascalZrbEntityNameData,
 )
-from module.snake_zrb_module_name.schema.snake_zrb_entity_name import PascalZrbEntityNameData
-from module.auth.schema.token import AccessTokenData
 
 
 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 "snake_zrb_module_name.snake_zrb_entity_name"')
+    logger.info(
+        '🥪 Register RPC handlers for "snake_zrb_module_name.snake_zrb_entity_name"'
+    )
 
-    @rpc_server.register('snake_zrb_module_name_get_snake_zrb_entity_name')
+    @rpc_server.register("snake_zrb_module_name_get_snake_zrb_entity_name")
     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 snake_zrb_entity_name_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('snake_zrb_module_name_get_snake_zrb_entity_name_by_id')
+    @rpc_server.register("snake_zrb_module_name_get_snake_zrb_entity_name_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 snake_zrb_entity_name_model.get_by_id(id)
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('snake_zrb_module_name_insert_snake_zrb_entity_name')
+    @rpc_server.register("snake_zrb_module_name_insert_snake_zrb_entity_name")
     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
+        data["created_by"] = user_token_data.user_id
+        data["updated_by"] = user_token_data.user_id
         row = await snake_zrb_entity_name_model.insert(
             data=PascalZrbEntityNameData(**data)
         )
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('snake_zrb_module_name_update_snake_zrb_entity_name')
+    @rpc_server.register("snake_zrb_module_name_update_snake_zrb_entity_name")
     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
+        data["updated_by"] = user_token_data.user_id
         row = await snake_zrb_entity_name_model.update(
             id=id, data=PascalZrbEntityNameData(**data)
         )
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('snake_zrb_module_name_delete_snake_zrb_entity_name')
-    async def delete(
-        id: str,
-        user_token_data: Mapping[str, Any]
-    ) -> Mapping[str, Any]:
+    @rpc_server.register("snake_zrb_module_name_delete_snake_zrb_entity_name")
+    async def delete(id: str, user_token_data: Mapping[str, Any]) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
         row = await snake_zrb_entity_name_model.delete(id=id)
-        return row.dict()
+        return row.model_dump()

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/src/module/snake_zrb_module_name/schema/snake_zrb_entity_name.py

@@ -1,5 +1,6 @@
 from typing import List
-from core.schema import BaseDateTimeSchema, BaseCountSchema
+
+from core.schema import BaseCountSchema, BaseDateTimeSchema
 
 
 class PascalZrbEntityNameData(BaseDateTimeSchema):
@@ -11,6 +12,7 @@ class PascalZrbEntityName(PascalZrbEntityNameData):
 
     class Config:
         orm_mode = True
+        from_attributes = True
 
 
 class PascalZrbEntityNameResult(BaseCountSchema):

zrb/builtin/generator/fastapp_crud/template/src/kebab-zrb-app-name/test/snake_zrb_module_name/test_snake_zrb_entity_name.py

@@ -1,228 +1,198 @@
 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 = {
-    'snake_zrb_column_name': 'test-kebab-create-entity-name-success'
+    "snake_zrb_column_name": "test-kebab-create-entity-name-success"
 }
 to_be_updated_success_data = {
-    'snake_zrb_column_name': 'test-kebab-zrb-entity-name-to-be-updated-success'
+    "snake_zrb_column_name": "test-kebab-zrb-entity-name-to-be-updated-success"
 }
 updated_success_data = {
-    'snake_zrb_column_name': 'test-kebab-zrb-entity-name-updated-success'
+    "snake_zrb_column_name": "test-kebab-zrb-entity-name-updated-success"
 }
 to_be_deleted_success_data = {
-    'snake_zrb_column_name': 'test-kebab-zrb-entity-name-to-be-deleted-success'
+    "snake_zrb_column_name": "test-kebab-zrb-entity-name-to-be-deleted-success"
 }
 
 
 @pytest.mark.asyncio
 async def test_insert_snake_zrb_entity_name_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 snake_zrb_entity_name
         create_response = await client.post(
-            '/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name',
+            "/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name",
             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/snake_zrb_module_name/kebab-zrb-plural-entity-name/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{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/snake_zrb_module_name/kebab-zrb-plural-entity-name',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            "/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name",
+            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_snake_zrb_entity_name_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 snake_zrb_entity_name
         create_response = await client.post(
-            '/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name',
+            "/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name",
             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 snake_zrb_entity_name
         update_response = await client.put(
-            f'/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{create_response_id}',
+            f"/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{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/snake_zrb_module_name/kebab-zrb-plural-entity-name/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{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/snake_zrb_module_name/kebab-zrb-plural-entity-name',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            "/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name",
+            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_snake_zrb_entity_name_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 snake_zrb_entity_name
         create_response = await client.post(
-            '/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name',
+            "/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name",
             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 snake_zrb_entity_name
         delete_response = await client.delete(
-            f'/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{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/snake_zrb_module_name/kebab-zrb-plural-entity-name/{create_response_id}',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            f"/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name/{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/snake_zrb_module_name/kebab-zrb-plural-entity-name',
-            headers={
-                'Authorization': 'Bearer ' + admin_access_token
-            }
+            "/api/v1/snake_zrb_module_name/kebab-zrb-plural-entity-name",
+            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