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

@@ -1,10 +1,15 @@
-from module.auth.schema.user import User
 from config import (
-    app_auth_admin_user_id, app_auth_admin_username, app_auth_admin_password,
-    app_auth_admin_email, app_auth_admin_phone, app_auth_guest_user_id,
-    app_auth_guest_username, app_auth_guest_email,
-    app_auth_guest_phone
+    app_auth_admin_email,
+    app_auth_admin_password,
+    app_auth_admin_phone,
+    app_auth_admin_user_id,
+    app_auth_admin_username,
+    app_auth_guest_email,
+    app_auth_guest_phone,
+    app_auth_guest_user_id,
+    app_auth_guest_username,
 )
+from module.auth.schema.user import User
 
 admin_user_password = app_auth_admin_password
 
@@ -15,7 +20,7 @@ admin_user = User(
     phone=app_auth_admin_phone,
     groups=[],
     permissions=[],
-    description='System administrator'
+    description="System administrator",
 )
 
 guest_user = User(
@@ -25,5 +30,5 @@ guest_user = User(
     phone=app_auth_guest_phone,
     groups=[],
     permissions=[],
-    description='Visitor'
+    description="Visitor",
 )

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

@@ -1,18 +1,13 @@
+from module.auth.core.access_token.scheme import (
+    AccessTokenScheme,
+    create_oauth2_bearer_access_token_scheme,
+)
+from module.auth.core.access_token.util import AccessTokenUtil, JWTAccessTokenUtil
 from module.auth.core.authorizer.authorizer import Authorizer
 from module.auth.core.authorizer.rpc_authorizer import RPCAuthorizer
+from module.auth.core.password_hasher.bcrypt_password_hasher import BcryptPasswordHasher
 from module.auth.core.password_hasher.password_hasher import PasswordHasher
-from module.auth.core.password_hasher.bcrypt_password_hasher import (
-    BcryptPasswordHasher
-)
-from module.auth.core.access_token.scheme import (
-    AccessTokenScheme, create_oauth2_bearer_access_token_scheme
-)
-from module.auth.core.access_token.util import (
-    AccessTokenUtil, JWTAccessTokenUtil
-)
-from module.auth.core.refresh_token.util import (
-    RefreshTokenUtil, JWTRefreshTokenUtil
-)
+from module.auth.core.refresh_token.util import JWTRefreshTokenUtil, RefreshTokenUtil
 
 assert Authorizer
 assert RPCAuthorizer

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/core/access_token/scheme.py

@@ -1,10 +1,11 @@
 from typing import Callable, Optional
-from starlette.requests import Request
+
 from fastapi import Depends
 from fastapi.security import OAuth2PasswordBearer
+from module.auth.core.access_token.util import AccessTokenUtil
 from module.auth.schema.token import AccessTokenData
 from module.auth.schema.user import User
-from module.auth.core.access_token.util import AccessTokenUtil
+from starlette.requests import Request
 
 AccessTokenScheme = Callable[[Request], AccessTokenData]
 
@@ -13,25 +14,19 @@ def create_oauth2_bearer_access_token_scheme(
     guest_user: User,
     access_token_util: AccessTokenUtil,
     token_url: str,
-    token_cookie_key: str
+    token_cookie_key: str,
 ) -> AccessTokenScheme:
-
-    oauth2_scheme = OAuth2PasswordBearer(
-        tokenUrl=token_url, auto_error=False
-    )
+    oauth2_scheme = OAuth2PasswordBearer(tokenUrl=token_url, auto_error=False)
 
     async def oauth2_bearer_token_scheme(
-        request: Request,
-        token: Optional[str] = Depends(oauth2_scheme)
+        request: Request, token: Optional[str] = Depends(oauth2_scheme)
     ) -> AccessTokenData:
         token: Optional[str] = await oauth2_scheme(request)
         if token is None:
             token = request.cookies.get(token_cookie_key, None)
         if token is None:
             return AccessTokenData(
-                user_id=guest_user.id,
-                username=guest_user.username,
-                expire_seconds=300
+                user_id=guest_user.id, username=guest_user.username, expire_seconds=300
             )
         return access_token_util.decode(token, parse_expired_token=False)
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/core/access_token/util.py

@@ -1,15 +1,14 @@
-from typing import Any, Mapping
 from abc import ABC, abstractmethod
-from core.error import HTTPAPIException
-from module.auth.schema.token import AccessTokenData
 from datetime import datetime, timedelta
-from jose import jwt
+from typing import Any, Mapping
 
 import jsons
+from core.error import HTTPAPIException
+from jose import jwt
+from module.auth.schema.token import AccessTokenData
 
 
 class AccessTokenUtil(ABC):
-
     @abstractmethod
     def encode(self, token_data: AccessTokenData) -> str:
         pass
@@ -22,48 +21,39 @@ class AccessTokenUtil(ABC):
 
 
 class JWTAccessTokenUtil(AccessTokenUtil):
-
-    def __init__(self, secret_key: str, algorithm: str = 'HS256'):
+    def __init__(self, secret_key: str, algorithm: str = "HS256"):
         self.secret_key = secret_key
         self.algorithm = algorithm
 
     def encode(self, data: AccessTokenData) -> str:
-        expire_time = datetime.utcnow() + timedelta(
-            seconds=data.expire_seconds
-        )
-        sub = jsons.dumps(data.dict())
-        data_dict = {'sub': sub, 'exp': expire_time}
-        encoded_jwt = jwt.encode(
-            data_dict, self.secret_key, algorithm=self.algorithm
-        )
+        expire_time = datetime.utcnow() + timedelta(seconds=data.expire_seconds)
+        sub = jsons.dumps(data.model_dump())
+        data_dict = {"sub": sub, "exp": expire_time}
+        encoded_jwt = jwt.encode(data_dict, self.secret_key, algorithm=self.algorithm)
         return encoded_jwt
 
-    def decode(
-        self, token: str, parse_expired_token: bool = False
-    ) -> AccessTokenData:
+    def decode(self, token: str, parse_expired_token: bool = False) -> AccessTokenData:
         try:
             decoded_data = jwt.decode(
                 token,
                 self.secret_key,
                 algorithms=[self.algorithm],
-                options=self._get_decode_options(parse_expired_token)
+                options=self._get_decode_options(parse_expired_token),
             )
-            sub = jsons.loads(decoded_data['sub'])
-            token_data = AccessTokenData.parse_obj(sub)
+            sub = jsons.loads(decoded_data["sub"])
+            token_data = AccessTokenData.model_validate(sub)
             if not parse_expired_token:
-                expire_time = decoded_data['exp']
-                token_data.expire_seconds = ((
+                expire_time = decoded_data["exp"]
+                token_data.expire_seconds = (
                     datetime.fromtimestamp(expire_time) - datetime.utcnow()
-                ).total_seconds())
+                ).total_seconds()
                 if token_data.expire_seconds < 0:
-                    raise HTTPAPIException(422, 'Expired token')
+                    raise HTTPAPIException(422, "Expired token")
             return token_data
         except jwt.JWTError:
-            raise HTTPAPIException(422, 'Invalid token')
+            raise HTTPAPIException(422, "Invalid token")
 
-    def _get_decode_options(
-        self, parse_expired_token: bool
-    ) -> Mapping[str, Any]:
+    def _get_decode_options(self, parse_expired_token: bool) -> Mapping[str, Any]:
         if parse_expired_token:
-            return {'verify_exp': False}
+            return {"verify_exp": False}
         return {}

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

@@ -11,7 +11,5 @@ class Authorizer(ABC):
         pass
 
     @abstractmethod
-    async def is_having_permission(
-        self, user_id: str, *permission_names: str
-    ) -> bool:
+    async def is_having_permission(self, user_id: str, *permission_names: str) -> bool:
         pass

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/core/authorizer/rpc_authorizer.py

@@ -1,9 +1,8 @@
-from module.auth.core.authorizer.authorizer import Authorizer
 from core.rpc import Caller
+from module.auth.core.authorizer.authorizer import Authorizer
 
 
 class RPCAuthorizer(Authorizer):
-
     def __init__(
         self,
         rpc_caller: Caller,
@@ -17,22 +16,16 @@ class RPCAuthorizer(Authorizer):
         self.is_user_authorized_rpc_name = is_user_authorized_rpc_name
 
     async def is_admin(self, user_id: str) -> bool:
-        return await self.rpc_caller.call(
-            self.is_admin_rpc_name, user_id
-        )
+        return await self.rpc_caller.call(self.is_admin_rpc_name, user_id)
 
     async def is_guest(self, user_id: str) -> bool:
-        return await self.rpc_caller.call(
-            self.is_guest_rpc_name, user_id
-        )
+        return await self.rpc_caller.call(self.is_guest_rpc_name, user_id)
 
-    async def is_having_permission(
-        self, user_id: str, *permission_name: str
-    ) -> bool:
+    async def is_having_permission(self, user_id: str, *permission_name: str) -> bool:
         permission_map = await self.rpc_caller.call(
             self.is_user_authorized_rpc_name,
             id=user_id,
-            permission_name=permission_name
+            permission_name=permission_name,
         )
         for permission in permission_map:
             if not permission_map[permission]:

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/core/password_hasher/bcrypt_password_hasher.py

@@ -1,15 +1,10 @@
-from module.auth.core.password_hasher.password_hasher import PasswordHasher
 import bcrypt
+from module.auth.core.password_hasher.password_hasher import PasswordHasher
 
 
 class BcryptPasswordHasher(PasswordHasher):
-
     def hash_password(self, password: str) -> str:
-        return bcrypt.hashpw(
-            password.encode('utf-8'), bcrypt.gensalt()
-        ).decode('utf-8')
+        return bcrypt.hashpw(password.encode("utf-8"), bcrypt.gensalt()).decode("utf-8")
 
     def check_password(self, password: str, hashed_password: str) -> bool:
-        return bcrypt.checkpw(
-            password.encode('utf-8'), hashed_password.encode('utf-8')
-        )
+        return bcrypt.checkpw(password.encode("utf-8"), hashed_password.encode("utf-8"))

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

@@ -2,7 +2,6 @@ from abc import ABC, abstractmethod
 
 
 class PasswordHasher(ABC):
-
     @abstractmethod
     def hash_password(self, password: str) -> str:
         pass

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/core/refresh_token/util.py

@@ -1,14 +1,13 @@
 from abc import ABC, abstractmethod
-from core.error import HTTPAPIException
-from module.auth.schema.token import RefreshTokenData
 from datetime import datetime, timedelta
-from jose import jwt
 
 import jsons
+from core.error import HTTPAPIException
+from jose import jwt
+from module.auth.schema.token import RefreshTokenData
 
 
 class RefreshTokenUtil(ABC):
-
     @abstractmethod
     def encode(self, token_data: RefreshTokenData) -> str:
         pass
@@ -19,20 +18,15 @@ class RefreshTokenUtil(ABC):
 
 
 class JWTRefreshTokenUtil(RefreshTokenUtil):
-
-    def __init__(self, secret_key: str, algorithm: str = 'HS256'):
+    def __init__(self, secret_key: str, algorithm: str = "HS256"):
         self.secret_key = secret_key
         self.algorithm = algorithm
 
     def encode(self, data: RefreshTokenData) -> str:
-        expire_time = datetime.utcnow() + timedelta(
-            seconds=data.expire_seconds
-        )
-        sub = jsons.dumps(data.dict())
-        data_dict = {'sub': sub, 'exp': expire_time}
-        encoded_jwt = jwt.encode(
-            data_dict, self.secret_key, algorithm=self.algorithm
-        )
+        expire_time = datetime.utcnow() + timedelta(seconds=data.expire_seconds)
+        sub = jsons.dumps(data.model_dump())
+        data_dict = {"sub": sub, "exp": expire_time}
+        encoded_jwt = jwt.encode(data_dict, self.secret_key, algorithm=self.algorithm)
         return encoded_jwt
 
     def decode(self, token: str) -> RefreshTokenData:
@@ -40,14 +34,14 @@ class JWTRefreshTokenUtil(RefreshTokenUtil):
             decoded_data = jwt.decode(
                 token, self.secret_key, algorithms=[self.algorithm]
             )
-            sub = jsons.loads(decoded_data['sub'])
-            token_data = RefreshTokenData.parse_obj(sub)
-            expire_time = decoded_data['exp']
-            token_data.expire_seconds = ((
+            sub = jsons.loads(decoded_data["sub"])
+            token_data = RefreshTokenData.model_validate(sub)
+            expire_time = decoded_data["exp"]
+            token_data.expire_seconds = (
                 datetime.fromtimestamp(expire_time) - datetime.utcnow()
-            ).total_seconds())
+            ).total_seconds()
             if token_data.expire_seconds < 0:
-                raise HTTPAPIException(422, 'Expired token')
+                raise HTTPAPIException(422, "Expired token")
             return token_data
         except jwt.JWTError:
-            raise HTTPAPIException(422, 'Invalid token')
+            raise HTTPAPIException(422, "Invalid token")

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/group/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.group import (
-    Group, GroupData, GroupResult
-)
+from module.auth.schema.group import Group, GroupData, GroupResult
 from module.auth.schema.token import AccessTokenData
-from module.auth.component import access_token_scheme
 
 
 def register_api(
@@ -16,108 +15,102 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "auth.group"')
 
-    @app.get(
-        '/api/v1/auth/groups', response_model=GroupResult
-    )
+    @app.get("/api/v1/auth/groups", response_model=GroupResult)
     async def get_groups(
-        keyword: str = '', limit: int = 100, offset: int = 0,
+        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_group',
+                "auth_get_group",
                 keyword=keyword,
                 criterion={},
                 limit=limit,
                 offset=offset,
-                user_token_data=user_token_data.dict()
+                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
-    )
+    @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)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:group:get_by_id'
+            user_token_data.user_id, "auth:group:get_by_id"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_get_group_by_id',
-                id=id, user_token_data=user_token_data.dict()
+                "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
-    )
+    @app.post("/api/v1/auth/groups", response_model=Group)
     async def insert_group(
-        data: GroupData,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        data: GroupData, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:group:insert'
+            user_token_data.user_id, "auth:group:insert"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_insert_group',
-                data=data.dict(), user_token_data=user_token_data.dict()
+                "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
-    )
+    @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)
+        id: str,
+        data: GroupData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:group:update'
+            user_token_data.user_id, "auth:group:update"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_update_group',
-                id=id, data=data.dict(), user_token_data=user_token_data.dict()
+                "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
-    )
+    @app.delete("/api/v1/auth/groups/{id}", response_model=Group)
     async def delete_group(
-        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:group:delete'
+            user_token_data.user_id, "auth:group:delete"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_delete_group',
-                id=id, user_token_data=user_token_data.dict()
+                "auth_delete_group", id=id, user_token_data=user_token_data.model_dump()
             )
             return Group(**result_dict)
         except Exception as e:

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

@@ -1,11 +1,7 @@
+from module.auth.schema.group import Group, GroupData, GroupResult
 from module.log.core.historical_repo_model import HistoricalRepoModel
-from module.auth.schema.group import (
-    Group, GroupData, GroupResult
-)
 
 
-class GroupModel(
-    HistoricalRepoModel[Group, GroupData, GroupResult]
-):
+class GroupModel(HistoricalRepoModel[Group, GroupData, GroupResult]):
     schema_result_cls = GroupResult
-    log_entity_name = 'group'
+    log_entity_name = "group"

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

@@ -1,31 +1,31 @@
-from typing import Any, Mapping
 from abc import ABC
-from sqlalchemy import Column, String
-from sqlalchemy.orm import Session, relationship
-from core.repo import Repo, DBEntityMixin, DBRepo
-from module.auth.schema.group import Group, GroupData
+from typing import Any, Mapping
+
+from core.repo import DBEntityMixin, DBRepo, Repo
 from module.auth.component import Base
-from module.auth.entity.table import group_permission
 from module.auth.entity.permission.repo import DBEntityPermission
+from module.auth.entity.table import group_permission
+from module.auth.schema.group import Group, GroupData
+from sqlalchemy import Column, String
+from sqlalchemy.orm import Session, relationship
 
 
 class DBEntityGroup(Base, DBEntityMixin):
+    class Config:
+        orm_mode = True
+        from_attributes = True
+
     __tablename__ = "groups"
     name = Column(String)
     description = Column(String)
-    permissions = relationship(
-        "DBEntityPermission",
-        secondary=group_permission
-    )
+    permissions = relationship("DBEntityPermission", secondary=group_permission)
 
 
 class GroupRepo(Repo[Group, GroupData], ABC):
     pass
 
 
-class GroupDBRepo(
-    DBRepo[Group, GroupData], GroupRepo
-):
+class GroupDBRepo(DBRepo[Group, GroupData], GroupRepo):
     schema_cls = Group
     db_entity_cls = DBEntityGroup
 
@@ -34,7 +34,9 @@ class GroupDBRepo(
     ) -> Mapping[str, Any]:
         db_entity_map = super()._schema_data_to_db_entity_map(db, group_data)
         # Transform permissions
-        db_entity_map['permissions'] = db.query(DBEntityPermission).filter(
-            DBEntityPermission.id.in_(group_data.permissions)
-        ).all()
+        db_entity_map["permissions"] = (
+            db.query(DBEntityPermission)
+            .filter(DBEntityPermission.id.in_(group_data.permissions))
+            .all()
+        )
         return db_entity_map