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/auth/entity/group/rpc.py

@@ -1,77 +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 core.rpc import Caller, Server
 from module.auth.component.model.group_model import group_model
 from module.auth.schema.group import GroupData
 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 "auth.group"')
 
-    @rpc_server.register('auth_get_group')
+    @rpc_server.register("auth_get_group")
     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 group_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('auth_get_group_by_id')
+    @rpc_server.register("auth_get_group_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 group_model.get_by_id(id)
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('auth_insert_group')
+    @rpc_server.register("auth_insert_group")
     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 = AccessTokenData(**user_token_data)
-        data['created_by'] = user_token_data.user_id
-        data['updated_by'] = user_token_data.user_id
-        row = await group_model.insert(
-            data=GroupData(**data)
-        )
-        return row.dict()
+        data["created_by"] = user_token_data.user_id
+        data["updated_by"] = user_token_data.user_id
+        row = await group_model.insert(data=GroupData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('auth_update_group')
+    @rpc_server.register("auth_update_group")
     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 = AccessTokenData(**user_token_data)
-        data['updated_by'] = user_token_data.user_id
-        row = await group_model.update(
-            id=id, data=GroupData(**data)
-        )
-        return row.dict()
+        data["updated_by"] = user_token_data.user_id
+        row = await group_model.update(id=id, data=GroupData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('auth_delete_group')
-    async def delete(
-        id: str,
-        user_token_data: Mapping[str, Any]
-    ) -> Mapping[str, Any]:
+    @rpc_server.register("auth_delete_group")
+    async def delete(id: str, user_token_data: Mapping[str, Any]) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
         row = await group_model.delete(id=id)
-        return row.dict()
+        return row.model_dump()

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

@@ -1,14 +1,13 @@
-from fastapi import FastAPI, Depends
 from logging import Logger
+
+from core.error import HTTPAPIException
 from core.messagebus import Publisher
 from core.rpc import Caller
-from core.error import HTTPAPIException
+from fastapi import Depends, FastAPI
+from module.auth.component import access_token_scheme
 from module.auth.core import Authorizer
-from module.auth.schema.permission import (
-    Permission, PermissionData, PermissionResult
-)
+from module.auth.schema.permission import Permission, PermissionData, PermissionResult
 from module.auth.schema.token import AccessTokenData
-from module.auth.component import access_token_scheme
 
 
 def register_api(
@@ -16,109 +15,105 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "auth.permission"')
 
-    @app.get(
-        '/api/v1/auth/permissions', response_model=PermissionResult
-    )
+    @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)
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:permission:get'
+            user_token_data.user_id, "auth:permission:get"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_get_permission',
+                "auth_get_permission",
                 keyword=keyword,
                 criterion={},
                 limit=limit,
                 offset=offset,
-                user_token_data=user_token_data.dict()
+                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
-    )
+    @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)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:permission:get_by_id'
+            user_token_data.user_id, "auth:permission:get_by_id"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_get_permission_by_id',
-                id=id, user_token_data=user_token_data.dict()
+                "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
-    )
+    @app.post("/api/v1/auth/permissions", response_model=Permission)
     async def insert_permission(
         data: PermissionData,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:permission:insert'
+            user_token_data.user_id, "auth:permission:insert"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_insert_permission',
-                data=data.dict(), user_token_data=user_token_data.dict()
+                "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
-    )
+    @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)
+        id: str,
+        data: PermissionData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:permission:update'
+            user_token_data.user_id, "auth:permission:update"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_update_permission',
-                id=id, data=data.dict(), user_token_data=user_token_data.dict()
+                "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
-    )
+    @app.delete("/api/v1/auth/permissions/{id}", response_model=Permission)
     async def delete_permission(
-        id: str,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:permission:delete'
+            user_token_data.user_id, "auth:permission:delete"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_delete_permission',
-                id=id, user_token_data=user_token_data.dict()
+                "auth_delete_permission",
+                id=id,
+                user_token_data=user_token_data.model_dump(),
             )
             return Permission(**result_dict)
         except Exception as e:

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

@@ -1,16 +1,14 @@
 from core.messagebus.messagebus import Publisher
-from module.log.core.historical_repo_model import HistoricalRepoModel
-from module.auth.schema.permission import (
-    Permission, PermissionData, PermissionResult
-)
 from module.auth.entity.permission.repo import PermissionRepo
+from module.auth.schema.permission import Permission, PermissionData, PermissionResult
+from module.log.core.historical_repo_model import HistoricalRepoModel
 
 
 class PermissionModel(
     HistoricalRepoModel[Permission, PermissionData, PermissionResult]
 ):
     schema_result_cls = PermissionResult
-    log_entity_name = 'permission'
+    log_entity_name = "permission"
 
     def __init__(self, repo: PermissionRepo, publisher: Publisher):
         super().__init__(repo, publisher)
@@ -19,8 +17,8 @@ class PermissionModel(
         try:
             await self.repo.get_by_name(data.name)
         except Exception as e:
-            error_message = f'{e}'
-            if error_message.lower().startswith('not found'):
+            error_message = f"{e}"
+            if error_message.lower().startswith("not found"):
                 await self.repo.insert(data)
                 return
             raise e

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

@@ -1,11 +1,16 @@
 from abc import ABC, abstractmethod
-from sqlalchemy import Column, String
-from core.repo import Repo, DBEntityMixin, DBRepo
-from module.auth.schema.permission import Permission, PermissionData
+
+from core.repo import DBEntityMixin, DBRepo, Repo
 from module.auth.component import Base
+from module.auth.schema.permission import Permission, PermissionData
+from sqlalchemy import Column, String
 
 
 class DBEntityPermission(Base, DBEntityMixin):
+    class Config:
+        orm_mode = True
+        from_attributes = True
+
     __tablename__ = "permissions"
     name = Column(String)
     description = Column(String)
@@ -17,16 +22,14 @@ class PermissionRepo(Repo[Permission, PermissionData], ABC):
         pass
 
 
-class PermissionDBRepo(
-    DBRepo[Permission, PermissionData], PermissionRepo
-):
+class PermissionDBRepo(DBRepo[Permission, PermissionData], PermissionRepo):
     schema_cls = Permission
     db_entity_cls = DBEntityPermission
 
     async def get_by_name(self, name: str) -> Permission:
-        '''
+        """
         Find permission by name.
-        '''
+        """
         db = self._get_db_session()
         try:
             search_filter = DBEntityPermission.name == name

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

@@ -1,83 +1,66 @@
-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.component.model.permission_model import permission_model
 from module.auth.schema.permission import PermissionData
 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 "auth.permission"')
 
-    @rpc_server.register('auth_ensure_permission')
+    @rpc_server.register("auth_ensure_permission")
     async def ensure(data: Mapping[str, Any]):
-        await permission_model.ensure_permission(
-            PermissionData(**data)
-        )
+        await permission_model.ensure_permission(PermissionData(**data))
 
-    @rpc_server.register('auth_get_permission')
+    @rpc_server.register("auth_get_permission")
     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 permission_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('auth_get_permission_by_id')
+    @rpc_server.register("auth_get_permission_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 permission_model.get_by_id(id)
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('auth_insert_permission')
+    @rpc_server.register("auth_insert_permission")
     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 permission_model.insert(
-            data=PermissionData(**data)
-        )
-        return row.dict()
+        data["created_by"] = user_token_data.user_id
+        data["updated_by"] = user_token_data.user_id
+        row = await permission_model.insert(data=PermissionData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('auth_update_permission')
+    @rpc_server.register("auth_update_permission")
     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 permission_model.update(
-            id=id, data=PermissionData(**data)
-        )
-        return row.dict()
+        data["updated_by"] = user_token_data.user_id
+        row = await permission_model.update(id=id, data=PermissionData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('auth_delete_permission')
-    async def delete(
-        id: str,
-        user_token_data: Mapping[str, Any]
-    ) -> Mapping[str, Any]:
+    @rpc_server.register("auth_delete_permission")
+    async def delete(id: str, user_token_data: Mapping[str, Any]) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
         row = await permission_model.delete(id=id)
-        return row.dict()
+        return row.model_dump()

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

@@ -1,23 +1,23 @@
-from sqlalchemy import Column, String, Table, ForeignKey
 from module.auth.component import Base
+from sqlalchemy import Column, ForeignKey, String, Table
 
 user_group = Table(
-    'user_groups',
+    "user_groups",
     Base.metadata,
-    Column('user_id', String, ForeignKey('users.id')),
-    Column('group_id', String, ForeignKey('groups.id')),
+    Column("user_id", String, ForeignKey("users.id")),
+    Column("group_id", String, ForeignKey("groups.id")),
 )
 
 user_permission = Table(
-    'user_permissions',
+    "user_permissions",
     Base.metadata,
-    Column('user_id', String, ForeignKey('users.id')),
-    Column('permission_id', String, ForeignKey('permissions.id')),
+    Column("user_id", String, ForeignKey("users.id")),
+    Column("permission_id", String, ForeignKey("permissions.id")),
 )
 
 group_permission = Table(
-    'group_permissions',
+    "group_permissions",
     Base.metadata,
-    Column('group_id', String, ForeignKey('groups.id')),
-    Column('permission_id', String, ForeignKey('permissions.id')),
+    Column("group_id", String, ForeignKey("groups.id")),
+    Column("permission_id", String, ForeignKey("permissions.id")),
 )