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/user/rpc.py

@@ -1,116 +1,97 @@
-from typing import Any, Mapping, List, Union
 from logging import Logger
+from typing import Any, List, Mapping, Union
+
 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.user_model import user_model
-from module.auth.schema.user import UserData, UserLogin
 from module.auth.schema.token import AccessTokenData
+from module.auth.schema.user import UserData, UserLogin
 
 
 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.user"')
 
-    @rpc_server.register('auth_user_is_admin')
+    @rpc_server.register("auth_user_is_admin")
     async def user_is_admin(id: str) -> bool:
-        '''
+        """
         Used by RPC Authenticator
-        '''
+        """
         return await user_model.is_admin(id)
 
-    @rpc_server.register('auth_user_is_guest')
+    @rpc_server.register("auth_user_is_guest")
     async def user_is_guest(id: str) -> bool:
-        '''
+        """
         Used by RPC Authenticator
-        '''
+        """
         return await user_model.is_guest(id)
 
-    @rpc_server.register('auth_is_user_authorized')
+    @rpc_server.register("auth_is_user_authorized")
     async def is_user_having_permission(
         id: str, permission_name: Union[str, List[str]]
     ) -> Mapping[str, bool]:
-        '''
+        """
         Used by RPC Authenticator
-        '''
+        """
         if isinstance(permission_name, str):
             return await user_model.is_authorized(id, permission_name)
         return await user_model.is_authorized(id, *permission_name)
 
-    @rpc_server.register('auth_create_token')
+    @rpc_server.register("auth_create_token")
     async def create_token(login_data: Mapping[str, str]) -> Mapping[str, str]:
         result = await user_model.create_auth_token(UserLogin(**login_data))
-        return result.dict()
+        return result.model_dump()
 
-    @rpc_server.register('auth_refresh_token')
-    async def refresh_token(
-        refresh_token: str, access_token: str
-    ) -> Mapping[str, str]:
-        result = await user_model.refresh_auth_token(
-            refresh_token, access_token
-        )
-        return result.dict()
+    @rpc_server.register("auth_refresh_token")
+    async def refresh_token(refresh_token: str, access_token: str) -> Mapping[str, str]:
+        result = await user_model.refresh_auth_token(refresh_token, access_token)
+        return result.model_dump()
 
-    @rpc_server.register('auth_get_user')
+    @rpc_server.register("auth_get_user")
     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 user_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_user_by_id')
+    @rpc_server.register("auth_get_user_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 user_model.get_by_id(id)
-        return row.dict()
+        return row.model_dump()
 
-    @rpc_server.register('auth_insert_user')
+    @rpc_server.register("auth_insert_user")
     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 user_model.insert(
-            data=UserData(**data)
-        )
-        return row.dict()
+        data["created_by"] = user_token_data.user_id
+        data["updated_by"] = user_token_data.user_id
+        row = await user_model.insert(data=UserData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('auth_update_user')
+    @rpc_server.register("auth_update_user")
     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 user_model.update(
-            id=id, data=UserData(**data)
-        )
-        return row.dict()
+        data["updated_by"] = user_token_data.user_id
+        row = await user_model.update(id=id, data=UserData(**data))
+        return row.model_dump()
 
-    @rpc_server.register('auth_delete_user')
-    async def delete(
-        id: str,
-        user_token_data: Mapping[str, Any]
-    ) -> Mapping[str, Any]:
+    @rpc_server.register("auth_delete_user")
+    async def delete(id: str, user_token_data: Mapping[str, Any]) -> Mapping[str, Any]:
         user_token_data = AccessTokenData(**user_token_data)
         row = await user_model.delete(id=id)
-        return row.dict()
+        return row.model_dump()

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

@@ -1,12 +1,10 @@
 from logging import Logger
+
 from core.messagebus import Consumer, Publisher
 from core.rpc import Caller
 
 
 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 "auth"')

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

@@ -1,8 +1,6 @@
-from config import (
-    app_enable_auth_module
-)
-from component.log import logger
 from component.db_connection import engine
+from component.log import logger
+from config import app_enable_auth_module
 from helper.migration import migrate
 from module.auth.component import Base
 from module.auth.register_permission import register_permission
@@ -14,5 +12,5 @@ async def migrate_auth():
         return
     logger.info('🥪 Perform DB migration for "auth"')
     await migrate(engine=engine, Base=Base)
-    logger.info('🥪 Register permissions')
+    logger.info("🥪 Register permissions")
     await register_permission()

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

@@ -1,13 +1,15 @@
-from config import (
-    app_enable_rpc_server, app_enable_event_handler, app_enable_api,
-    app_enable_auth_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 module.auth.component import authorizer
+from config import (
+    app_enable_api,
+    app_enable_auth_module,
+    app_enable_event_handler,
+    app_enable_rpc_server,
+)
 from module.auth.api import register_api
+from module.auth.component import authorizer
 from module.auth.event import register_event
 from module.auth.rpc import register_rpc
 
@@ -22,19 +24,16 @@ def register_auth():
             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/auth/register_permission.py

@@ -1,44 +1,37 @@
 from typing import List, Optional
-from module.auth.schema.permission import PermissionData
+
 from module.auth.component.model.permission_model import permission_model
+from module.auth.schema.permission import PermissionData
 
-DEFAULT_ACTION_NAMES = ['get', 'get_by_id', 'insert', 'update', 'delete']
+DEFAULT_ACTION_NAMES = ["get", "get_by_id", "insert", "update", "delete"]
 ACTION_DESCRIPTION = {
-    'get': 'list all',
-    'get_by_id': 'get single',
-    'insert': 'insert new',
-    'update': 'update',
-    'delete': 'delete',
+    "get": "list all",
+    "get_by_id": "get single",
+    "insert": "insert new",
+    "update": "update",
+    "delete": "delete",
 }
 
 
 async def ensure_entity_permission(
-    module_name: str,
-    entity_name: str,
-    action_names: Optional[List[str]] = None
+    module_name: str, entity_name: str, action_names: Optional[List[str]] = None
 ):
     if action_names is None:
         action_names = DEFAULT_ACTION_NAMES
     for action_name in action_names:
         caption = ACTION_DESCRIPTION[action_name]
-        await permission_model.ensure_permission(PermissionData(
-            name=f'{module_name}:{entity_name}:{action_name}',
-            description=f'Allow {caption} {entity_name} on {module_name}'
-        ))
+        await permission_model.ensure_permission(
+            PermissionData(
+                name=f"{module_name}:{entity_name}:{action_name}",
+                description=f"Allow {caption} {entity_name} on {module_name}",
+            )
+        )
 
 
 async def register_permission():
+    await ensure_entity_permission(module_name="auth", entity_name="group")
+    await ensure_entity_permission(module_name="auth", entity_name="permission")
+    await ensure_entity_permission(module_name="auth", entity_name="user")
     await ensure_entity_permission(
-        module_name='auth', entity_name='group'
-    )
-    await ensure_entity_permission(
-        module_name='auth', entity_name='permission'
-    )
-    await ensure_entity_permission(
-        module_name='auth', entity_name='user'
-    )
-    await ensure_entity_permission(
-        module_name='log',
-        entity_name='activity',
-        action_names=['get', 'get_by_id']
+        module_name="log", entity_name="activity", action_names=["get", "get_by_id"]
     )

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

@@ -1,22 +1,14 @@
 from logging import Logger
+
 from core.messagebus import Publisher
 from core.rpc import Caller, Server
-from module.auth.entity.permission.rpc import (
-    register_rpc as register_permission_rpc
-)
-from module.auth.entity.group.rpc import (
-    register_rpc as register_group_rpc
-)
-from module.auth.entity.user.rpc import (
-    register_rpc as register_user_rpc
-)
+from module.auth.entity.group.rpc import register_rpc as register_group_rpc
+from module.auth.entity.permission.rpc import register_rpc as register_permission_rpc
+from module.auth.entity.user.rpc import register_rpc as register_user_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 "auth"')
     register_permission_rpc(logger, rpc_server, rpc_caller, publisher)

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

@@ -1,5 +1,6 @@
 from typing import List
-from core.schema import BaseDateTimeSchema, BaseCountSchema
+
+from core.schema import BaseCountSchema, BaseDateTimeSchema
 from module.auth.schema.permission import Permission
 
 
@@ -13,11 +14,12 @@ class GroupData(GroupBase):
 
 
 class Group(GroupBase):
-    id: str
-    permissions: List[Permission] = []
-
     class Config:
         orm_mode = True
+        from_attributes = True
+
+    id: str
+    permissions: List[Permission] = []
 
 
 class GroupResult(BaseCountSchema):

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

@@ -1,5 +1,6 @@
 from typing import List
-from core.schema import BaseDateTimeSchema, BaseCountSchema
+
+from core.schema import BaseCountSchema, BaseDateTimeSchema
 
 
 class PermissionData(BaseDateTimeSchema):
@@ -12,6 +13,7 @@ class Permission(PermissionData):
 
     class Config:
         orm_mode = True
+        from_attributes = True
 
 
 class PermissionResult(BaseCountSchema):

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/schema/request.py

@@ -1,4 +1,5 @@
 from typing import List
+
 from pydantic import BaseModel
 
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/schema/token.py

@@ -4,12 +4,12 @@ from pydantic import BaseModel
 class AccessTokenData(BaseModel):
     user_id: str
     username: str
-    expire_seconds: int
+    expire_seconds: int | float
 
 
 class RefreshTokenData(BaseModel):
     user_id: str
-    expire_seconds: int
+    expire_seconds: int | float
 
 
 class TokenResponse(BaseModel):

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

@@ -1,8 +1,9 @@
 from typing import List
-from pydantic import BaseModel
-from core.schema import BaseDateTimeSchema, BaseCountSchema
-from module.auth.schema.permission import Permission
+
+from core.schema import BaseCountSchema, BaseDateTimeSchema
 from module.auth.schema.group import Group
+from module.auth.schema.permission import Permission
+from pydantic import BaseModel
 
 
 class UserBase(BaseDateTimeSchema):

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

@@ -1,11 +1,10 @@
-from fastapi import FastAPI
 from logging import Logger
+
 from core.messagebus import Publisher
 from core.rpc import Caller
+from fastapi import FastAPI
 from module.auth.core import Authorizer
-from module.log.entity.activity.api import (
-    register_api as register_activity_api
-)
+from module.log.entity.activity.api import register_api as register_activity_api
 
 
 def register_api(
@@ -13,7 +12,7 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "log"')
     register_activity_api(logger, app, authorizer, rpc_caller, publisher)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/log/component/model/activity_model.py

@@ -1,10 +1,4 @@
-from module.log.component.repo.activity_repo import (
-    activity_repo
-)
-from module.log.entity.activity.model import (
-    ActivityModel
-)
+from module.log.component.repo.activity_repo import activity_repo
+from module.log.entity.activity.model import ActivityModel
 
-activity_model: ActivityModel = ActivityModel(
-    activity_repo
-)
+activity_model: ActivityModel = ActivityModel(activity_repo)

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

@@ -1,9 +1,5 @@
-from component.log import logger
 from component.db_connection import engine
-from module.log.entity.activity.repo import (
-    ActivityRepo, ActivityDBRepo
-)
+from component.log import logger
+from module.log.entity.activity.repo import ActivityDBRepo, ActivityRepo
 
-activity_repo: ActivityRepo = ActivityDBRepo(
-    logger=logger, engine=engine
-)
+activity_repo: ActivityRepo = ActivityDBRepo(logger=logger, engine=engine)

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

@@ -1,15 +1,15 @@
-from typing import TypeVar, Type
-from pydantic import BaseModel
-from core.repo.repo import Repo
+from typing import Type, TypeVar
+
+import jsons
 from core.messagebus.messagebus import Publisher
 from core.model.repo_model import RepoModel
+from core.repo.repo import Repo
 from module.log.schema.activity import ActivityData
-import jsons
-
+from pydantic import BaseModel
 
-Schema = TypeVar('Schema', bound=BaseModel)
-SchemaData = TypeVar('SchemaData', bound=BaseModel)
-SchemaResult = TypeVar('SchemaResult', bound=BaseModel)
+Schema = TypeVar("Schema", bound=BaseModel)
+SchemaData = TypeVar("SchemaData", bound=BaseModel)
+SchemaResult = TypeVar("SchemaResult", bound=BaseModel)
 
 
 class HistoricalRepoModel(RepoModel[Schema, SchemaData, SchemaResult]):
@@ -22,23 +22,23 @@ class HistoricalRepoModel(RepoModel[Schema, SchemaData, SchemaResult]):
 
     async def insert(self, data: SchemaData) -> Schema:
         result = await super().insert(data)
-        await self._publish_activity(action='insert', result=result)
+        await self._publish_activity(action="insert", result=result)
         return result
 
     async def update(self, id: str, data: SchemaData) -> Schema:
         result = await self.repo.update(id, data)
-        await self._publish_activity(action='update', result=result)
+        await self._publish_activity(action="update", result=result)
         return result
 
     async def delete(self, id: str) -> Schema:
         result = await self.repo.delete(id)
-        await self._publish_activity(action='delete', result=result)
+        await self._publish_activity(action="delete", result=result)
         return result
 
     async def _publish_activity(self, action: str, result: Schema):
         activity_data = ActivityData(
             action=action,
             entity=self.log_entity_name,
-            data=jsons.dumps(result.dict())
+            data=jsons.dumps(result.model_dump()),
         )
-        await self.publisher.publish('log_new_activity', activity_data.dict())
+        await self.publisher.publish("log_new_activity", activity_data.model_dump())

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

@@ -1,12 +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.log.schema.activity import Activity, ActivityResult
 from module.auth.schema.token import AccessTokenData
-from module.auth.component import access_token_scheme
+from module.log.schema.activity import Activity, ActivityResult
 
 
 def register_api(
@@ -14,49 +15,47 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "log.activity"')
 
-    @app.get(
-        '/api/v1/log/activities', response_model=ActivityResult
-    )
+    @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)
+        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, 'log:activity:get'
+            user_token_data.user_id, "log:activity:get"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'log_get_activity',
+                "log_get_activity",
                 keyword=keyword,
                 criterion={},
                 limit=limit,
                 offset=offset,
-                user_token_data=user_token_data.dict()
+                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
-    )
+    @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)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'log:activity:get_by_id'
+            user_token_data.user_id, "log:activity:get_by_id"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'log_get_activity_by_id',
-                id=id, user_token_data=user_token_data.dict()
+                "log_get_activity_by_id",
+                id=id,
+                user_token_data=user_token_data.model_dump(),
             )
             return Activity(**result_dict)
         except Exception as e:

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

@@ -1,20 +1,18 @@
-from typing import Any, Mapping
 from logging import Logger
-from core.messagebus import Publisher, Consumer
+from typing import Any, Mapping
+
+from core.messagebus import Consumer, Publisher
 from core.rpc import Caller
 from module.log.component.model.activity_model import activity_model
 from module.log.schema.activity import ActivityData
 
 
 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.activity"')
 
-    @consumer.register('log_new_activity')
+    @consumer.register("log_new_activity")
     async def insert(
         data: Mapping[str, Any],
     ):

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

@@ -1,10 +1,6 @@
 from core.model import RepoModel
-from module.log.schema.activity import (
-    Activity, ActivityData, ActivityResult
-)
+from module.log.schema.activity import Activity, ActivityData, ActivityResult
 
 
-class ActivityModel(
-    RepoModel[Activity, ActivityData, ActivityResult]
-):
+class ActivityModel(RepoModel[Activity, ActivityData, ActivityResult]):
     schema_result_cls = ActivityResult