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/core/rpc/messagebus/caller.py

@@ -1,13 +1,13 @@
+import asyncio
+import logging
 from typing import Any, Callable
+
 from core.messagebus.messagebus import Admin, Consumer, Publisher
 from core.rpc.rpc import Caller, Message, Result
-import logging
 from ulid import ULID
-import asyncio
 
 
 class MessagebusCaller(Caller):
-
     def __init__(
         self,
         logger: logging.Logger,
@@ -15,7 +15,7 @@ class MessagebusCaller(Caller):
         publisher: Publisher,
         consumer_factory: Callable[[], Consumer],
         timeout: float = 30,
-        check_reply_interval: float = 0.1
+        check_reply_interval: float = 0.1,
     ):
         self.logger = logger
         self.admin = admin
@@ -26,7 +26,7 @@ class MessagebusCaller(Caller):
 
     async def call(self, rpc_name: str, *args: Any, **kwargs: Any):
         random_uuid = str(ULID())
-        reply_event_name = f'reply_{rpc_name}_{random_uuid}'
+        reply_event_name = f"reply_{rpc_name}_{random_uuid}"
         await self.admin.create_events([reply_event_name])
         reply_consumer = self.consumer_factory()
         reply_received_event = asyncio.Event()
@@ -46,32 +46,30 @@ class MessagebusCaller(Caller):
                 rpc_name,
                 Message(
                     reply_event=reply_event_name, args=args, kwargs=kwargs
-                ).to_dict()
+                ).to_dict(),
             )
             await asyncio.gather(task)
-            await asyncio.wait_for(
-                reply_received_event.wait(), timeout=self.timeout
-            )
+            await asyncio.wait_for(reply_received_event.wait(), timeout=self.timeout)
         except asyncio.TimeoutError:
             self.logger.error(
-                '🤙 [messagebus-rpc-caller] ' +
-                f'Timeout while waiting for reply event {reply_event_name}'
+                "🤙 [messagebus-rpc-caller] "
+                + f"Timeout while waiting for reply event {reply_event_name}"
             )
             raise Exception(
-                f'Timeout while waiting for reply event: {reply_event_name}'
+                f"Timeout while waiting for reply event: {reply_event_name}"
             )
         finally:
             await self._clean_up(reply_consumer, reply_event_name)
         # raise call_error or return call_result
-        if call_error != '':
+        if call_error != "":
             self.logger.error(
-                '🤙 [messagebus-rpc-caller] RPC ' +
-                f'"{rpc_name}" returning error: {call_error}'
+                "🤙 [messagebus-rpc-caller] RPC "
+                + f'"{rpc_name}" returning error: {call_error}'
             )
             raise Exception(call_error)
         self.logger.info(
-            '🤙 [messagebus-rpc-caller] RPC ' +
-            f'"{rpc_name}" returning result: {call_result}'
+            "🤙 [messagebus-rpc-caller] RPC "
+            + f'"{rpc_name}" returning result: {call_result}'
         )
         return call_result
 
@@ -79,8 +77,8 @@ class MessagebusCaller(Caller):
         try:
             await reply_consumer.stop()
         except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error('🤙 [messagebus-rpc-caller]', exc_info=True)
+            self.logger.error("🤙 [messagebus-rpc-caller]", exc_info=True)
         try:
             await self.admin.delete_events([reply_event_name])
         except (asyncio.CancelledError, GeneratorExit, Exception):
-            self.logger.error('🤙 [messagebus-rpc-caller]', exc_info=True)
+            self.logger.error("🤙 [messagebus-rpc-caller]", exc_info=True)

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/rpc/messagebus/server.py

@@ -1,18 +1,15 @@
+import inspect
+import logging
 from typing import Any, Mapping
+
 from core.messagebus.messagebus import Consumer, Publisher
-from core.rpc.rpc import Server, TRPCHandler, Message, Result
-import logging
-import inspect
+from core.rpc.rpc import Message, Result, Server, TRPCHandler
 from pydantic import BaseModel
 
 
 class MessagebusServer(Server):
-
     def __init__(
-        self,
-        logger: logging.Logger,
-        consumer: Consumer,
-        publisher: Publisher
+        self, logger: logging.Logger, consumer: Consumer, publisher: Publisher
     ):
         self.logger = logger
         self.consumer = consumer
@@ -34,16 +31,16 @@ class MessagebusServer(Server):
                 reply_event = message.reply_event
                 # get reply
                 self.logger.info(
-                    '🤙 [messagebus-rpc-server] ' +
-                    f'Invoke RPC: {rpc_name} ' +
-                    f', args: {args} ' +
-                    f', kwargs: {kwargs} ' +
-                    f', reply_event: {reply_event}'
+                    "🤙 [messagebus-rpc-server] "
+                    + f"Invoke RPC: {rpc_name} "
+                    + f", args: {args} "
+                    + f", kwargs: {kwargs} "
+                    + f", reply_event: {reply_event}"
                 )
                 try:
                     result = await self._run_handler(handler, *args, **kwargs)
                     if isinstance(result, BaseModel):
-                        result = result.dict()
+                        result = result.model_dump()
                     # publish result
                     await self.publisher.publish(
                         reply_event, Result(result=result).to_dict()
@@ -52,13 +49,12 @@ class MessagebusServer(Server):
                     self.logger.error(e, exc_info=True)
                     # publish error
                     await self.publisher.publish(
-                        reply_event, Result(error=f'{e}').to_dict()
+                        reply_event, Result(error=f"{e}").to_dict()
                     )
+
         return wrapper
 
-    async def _run_handler(
-        self, handler: TRPCHandler, *args: Any, **kwargs: Any
-    ):
+    async def _run_handler(self, handler: TRPCHandler, *args: Any, **kwargs: Any):
         if inspect.iscoroutinefunction(handler):
             return await handler(*args, **kwargs)
         return handler(*args, **kwargs)

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

@@ -1,9 +1,9 @@
-from typing import Any, Callable, List, Mapping, TypeVar
 from abc import ABC, abstractmethod
+from typing import Any, Callable, List, Mapping, TypeVar
 
 TRPCHandler = Callable[..., Any]
-TMessage = TypeVar('TMessage', bound='Message')
-TResult = TypeVar('TResult', bound='Result')
+TMessage = TypeVar("TMessage", bound="Message")
+TResult = TypeVar("TResult", bound="Result")
 
 
 class Caller(ABC):
@@ -26,51 +26,38 @@ class Server(ABC):
         pass
 
 
-class Message():
-    def __init__(
-        self,
-        reply_event: str,
-        args: List[Any],
-        kwargs: Mapping[str, Any]
-    ):
+class Message:
+    def __init__(self, reply_event: str, args: List[Any], kwargs: Mapping[str, Any]):
         self.reply_event = reply_event
         self.args = args
         self.kwargs = kwargs
 
     def to_dict(self):
         return {
-            'args': self.args,
-            'kwargs': self.kwargs,
-            'reply_event': self.reply_event
+            "args": self.args,
+            "kwargs": self.kwargs,
+            "reply_event": self.reply_event,
         }
 
     @classmethod
     def from_dict(cls, dictionary: Mapping[str, Any]) -> TMessage:
         return cls(
-            reply_event=dictionary.get('reply_event', ''),
-            args=dictionary.get('args', []),
-            kwargs=dictionary.get('kwargs', {})
+            reply_event=dictionary.get("reply_event", ""),
+            args=dictionary.get("args", []),
+            kwargs=dictionary.get("kwargs", {}),
         )
 
 
-class Result():
-    def __init__(
-        self,
-        result: Any = None,
-        error: str = ''
-    ):
+class Result:
+    def __init__(self, result: Any = None, error: str = ""):
         self.result = result
         self.error = error
 
     def to_dict(self):
-        return {
-            'result': self.result,
-            'error': self.error
-        }
+        return {"result": self.result, "error": self.error}
 
     @classmethod
     def from_dict(cls, dictionary: Mapping[str, Any]) -> TResult:
         return cls(
-            result=dictionary.get('result', None),
-            error=dictionary.get('error', '')
+            result=dictionary.get("result", None), error=dictionary.get("error", "")
         )

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

@@ -1,4 +1,4 @@
-from core.schema.base_schema import BaseDateTimeSchema, BaseCountSchema
+from core.schema.base_schema import BaseCountSchema, BaseDateTimeSchema
 
 assert BaseDateTimeSchema
 assert BaseCountSchema

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/schema/base_schema.py

@@ -1,13 +1,14 @@
+import datetime
 from typing import Optional
+
 from pydantic import BaseModel
-import datetime
 
 
 class BaseDateTimeSchema(BaseModel):
-    created_at: Optional[datetime.datetime]
-    created_by: Optional[str]
-    updated_at: Optional[datetime.datetime]
-    updated_by: Optional[str]
+    created_at: Optional[datetime.datetime] = None
+    created_by: Optional[str] = None
+    updated_at: Optional[datetime.datetime] = None
+    updated_by: Optional[str] = None
 
 
 class BaseCountSchema(BaseModel):

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

@@ -1,6 +1,4 @@
-from core.serializer.serializer import (
-    Serializer, CustomSerializer, JsonSerializer
-)
+from core.serializer.serializer import CustomSerializer, JsonSerializer, Serializer
 
 assert Serializer
 assert CustomSerializer

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/core/serializer/serializer.py

@@ -1,5 +1,6 @@
-from typing import Any, Callable
 from abc import ABC, abstractmethod
+from typing import Any, Callable
+
 import jsons
 
 
@@ -14,9 +15,7 @@ class Serializer(ABC):
 
 
 class CustomSerializer(Serializer):
-    def __init__(
-        self, encoder: Callable[[Any], Any], decoder: Callable[[Any], Any]
-    ):
+    def __init__(self, encoder: Callable[[Any], Any], decoder: Callable[[Any], Any]):
         self.encoder = encoder
         self.decoder = decoder
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/helper/async_task.py

@@ -1,12 +1,9 @@
-from typing import Awaitable, Callable
 import asyncio
 import inspect
+from typing import Awaitable, Callable
 
 
-def create_task(
-    awaitable: Awaitable,
-    on_error: Callable
-) -> asyncio.Task:
+def create_task(awaitable: Awaitable, on_error: Callable) -> asyncio.Task:
     async def critical_task(awaitable):
         try:
             return await awaitable
@@ -14,4 +11,5 @@ def create_task(
             if inspect.iscoroutinefunction(on_error):
                 return await on_error(e)
             return on_error(e)
+
     return asyncio.create_task(critical_task(awaitable))

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/helper/conversion.py

@@ -1,21 +1,21 @@
 import logging
 
 LOGGING_LEVEL_MAP = {
-    'critical': logging.CRITICAL,
-    'fatal': logging.FATAL,
-    'error': logging.ERROR,
-    'warning': logging.WARNING,
-    'warn': logging.WARN,
-    'info': logging.INFO,
-    'debug': logging.DEBUG,
-    'notset': logging.NOTSET,
+    "critical": logging.CRITICAL,
+    "fatal": logging.FATAL,
+    "error": logging.ERROR,
+    "warning": logging.WARNING,
+    "warn": logging.WARN,
+    "info": logging.INFO,
+    "debug": logging.DEBUG,
+    "notset": logging.NOTSET,
 }
 
 
 def str_to_boolean(value: str):
-    if value.lower() in ('0', 'false', 'no', 'n'):
+    if value.lower() in ("0", "false", "no", "n"):
         return False
-    if value.lower() in ('1', 'true', 'yes', 'y'):
+    if value.lower() in ("1", "true", "yes", "y"):
         return True
     raise Exception(f'Cannot convert to boolean: "{value}"')
 

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/helper/migration.py

@@ -1,21 +1,20 @@
-from alembic.migration import MigrationContext
 from alembic.autogenerate import produce_migrations
-from alembic.operations.ops import ModifyTableOps
+from alembic.migration import MigrationContext
 from alembic.operations import Operations
+from alembic.operations.ops import ModifyTableOps
 from sqlalchemy import Engine
 from sqlalchemy.orm import DeclarativeBase
 
 
 async def migrate(engine: Engine, Base: DeclarativeBase):
-    '''
+    """
     Generate migration and run it
     See: https://alembic.sqlalchemy.org/en/latest/cookbook.html#run-alembic-operation-objects-directly-as-in-from-autogenerate  # noqa
-    '''
+    """
     connection = engine.connect()
     migration_context = MigrationContext.configure(connection)
     migration_script = produce_migrations(
-        context=migration_context,
-        metadata=Base.metadata
+        context=migration_context, metadata=Base.metadata
     )
     operations = Operations(migration_context)
     use_batch = engine.name == "sqlite"
@@ -23,10 +22,7 @@ async def migrate(engine: Engine, Base: DeclarativeBase):
     stack = [migration_script.upgrade_ops]
     while stack:
         elem = stack.pop(0)
-        if (
-            hasattr(elem, 'table_name') and
-            elem.table_name not in Base.metadata.tables
-        ):
+        if hasattr(elem, "table_name") and elem.table_name not in Base.metadata.tables:
             # We want the migration leave all unrelated tables as is
             continue
 

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

@@ -1,6 +1,7 @@
+import asyncio
+
 from module.auth.migrate import migrate_auth
 from module.log.migrate import migrate_log
-import asyncio
 
 
 async def migrate():
@@ -8,5 +9,5 @@ async def migrate():
     await migrate_log()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     asyncio.run(migrate())

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

@@ -1,18 +1,13 @@
-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.auth.entity.permission.api import (
-    register_api as register_permission_api
-)
-from module.auth.entity.group.api import (
-    register_api as register_group_api
-)
-from module.auth.entity.user.api import (
-    register_api as register_user_api,
-    register_auth_api as register_user_login_api
-)
+from module.auth.entity.group.api import register_api as register_group_api
+from module.auth.entity.permission.api import register_api as register_permission_api
+from module.auth.entity.user.api import register_api as register_user_api
+from module.auth.entity.user.api import register_auth_api as register_user_login_api
 
 
 def register_api(
@@ -20,7 +15,7 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "auth"')
     register_user_login_api(logger, app, authorizer, rpc_caller, publisher)

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

@@ -1,13 +1,11 @@
-from module.auth.component.authorizer import authorizer
-from module.auth.component.base import Base
-from module.auth.component.password_hasher import password_hasher
 from module.auth.component.access_token_scheme import access_token_scheme
 from module.auth.component.access_token_util import access_token_util
+from module.auth.component.authorizer import authorizer
+from module.auth.component.base import Base
 from module.auth.component.bearer_token_scheme import bearer_token_scheme
+from module.auth.component.password_hasher import password_hasher
 from module.auth.component.refresh_token_util import refresh_token_util
-from module.auth.component.user import (
-    admin_user, admin_user_password, guest_user
-)
+from module.auth.component.user import admin_user, admin_user_password, guest_user
 
 assert authorizer
 assert Base

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

@@ -1,14 +1,13 @@
-from module.auth.core import (
-    AccessTokenScheme, create_oauth2_bearer_access_token_scheme
-)
+from config import app_auth_access_token_cookie_key
 from module.auth.component.access_token_util import access_token_util
 from module.auth.component.user import guest_user
-from config import app_auth_access_token_cookie_key
-
+from module.auth.core import AccessTokenScheme, create_oauth2_bearer_access_token_scheme
 
-access_token_scheme: AccessTokenScheme = create_oauth2_bearer_access_token_scheme( # noqa
-    guest_user=guest_user,
-    access_token_util=access_token_util,
-    token_url='/api/v1/auth/login-oauth',
-    token_cookie_key=app_auth_access_token_cookie_key
+access_token_scheme: AccessTokenScheme = (
+    create_oauth2_bearer_access_token_scheme(  # noqa
+        guest_user=guest_user,
+        access_token_util=access_token_util,
+        token_url="/api/v1/auth/login-oauth",
+        token_cookie_key=app_auth_access_token_cookie_key,
+    )
 )

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

@@ -1,17 +1,18 @@
 from config import (
-    app_auth_access_token_type, app_auth_jwt_token_algorithm,
-    app_auth_jwt_token_secret_key
+    app_auth_access_token_type,
+    app_auth_jwt_token_algorithm,
+    app_auth_jwt_token_secret_key,
 )
 from module.auth.core import AccessTokenUtil, JWTAccessTokenUtil
 
 
 def init_token_util() -> AccessTokenUtil:
-    if app_auth_access_token_type.lower() == 'jwt':
+    if app_auth_access_token_type.lower() == "jwt":
         return JWTAccessTokenUtil(
             secret_key=app_auth_jwt_token_secret_key,
-            algorithm=app_auth_jwt_token_algorithm
+            algorithm=app_auth_jwt_token_algorithm,
         )
-    raise ValueError(f'Invalid auth token type: {app_auth_access_token_type}')
+    raise ValueError(f"Invalid auth token type: {app_auth_access_token_type}")
 
 
 access_token_util = init_token_util()

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

@@ -1,9 +1,9 @@
-from module.auth.core import Authorizer, RPCAuthorizer
 from component.rpc import rpc_caller
+from module.auth.core import Authorizer, RPCAuthorizer
 
 authorizer: Authorizer = RPCAuthorizer(
     rpc_caller=rpc_caller,
-    is_admin_rpc_name='auth_user_is_admin',
-    is_guest_rpc_name='auth_user_is_guest',
-    is_user_authorized_rpc_name='auth_is_user_authorized'
+    is_admin_rpc_name="auth_user_is_admin",
+    is_guest_rpc_name="auth_user_is_guest",
+    is_user_authorized_rpc_name="auth_is_user_authorized",
 )

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

@@ -1,5 +1,5 @@
 from fastapi.security import OAuth2PasswordBearer
 
 bearer_token_scheme = OAuth2PasswordBearer(
-    tokenUrl='/api/v1/auth/login-oauth', auto_error=False
+    tokenUrl="/api/v1/auth/login-oauth", auto_error=False
 )

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

@@ -1,16 +1,14 @@
+from component.messagebus import publisher
 from config import (
-    app_auth_admin_active, app_auth_access_token_expire_seconds,
-    app_auth_refresh_token_expire_seconds
+    app_auth_access_token_expire_seconds,
+    app_auth_admin_active,
+    app_auth_refresh_token_expire_seconds,
 )
-from component.messagebus import publisher
-from module.auth.component.repo.user_repo import user_repo
-from module.auth.entity.user.model import UserModel
 from module.auth.component import access_token_util, refresh_token_util
-from module.auth.component.user import (
-    admin_user, admin_user_password, guest_user
-)
 from module.auth.component.model.permission_model import permission_model
-
+from module.auth.component.repo.user_repo import user_repo
+from module.auth.component.user import admin_user, admin_user_password, guest_user
+from module.auth.entity.user.model import UserModel
 
 user_model: UserModel = UserModel(
     repo=user_repo,
@@ -22,5 +20,5 @@ user_model: UserModel = UserModel(
     refresh_token_expire_seconds=app_auth_refresh_token_expire_seconds,
     guest_user=guest_user,
     admin_user=admin_user if app_auth_admin_active else None,
-    admin_user_password=admin_user_password
+    admin_user_password=admin_user_password,
 )

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

@@ -1,3 +1,3 @@
-from module.auth.core import PasswordHasher, BcryptPasswordHasher
+from module.auth.core import BcryptPasswordHasher, PasswordHasher
 
 password_hasher: PasswordHasher = BcryptPasswordHasher()

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

@@ -1,17 +1,18 @@
 from config import (
-    app_auth_refresh_token_type, app_auth_jwt_token_algorithm,
-    app_auth_jwt_token_secret_key
+    app_auth_jwt_token_algorithm,
+    app_auth_jwt_token_secret_key,
+    app_auth_refresh_token_type,
 )
-from module.auth.core import RefreshTokenUtil, JWTRefreshTokenUtil
+from module.auth.core import JWTRefreshTokenUtil, RefreshTokenUtil
 
 
 def init_token_util() -> RefreshTokenUtil:
-    if app_auth_refresh_token_type.lower() == 'jwt':
+    if app_auth_refresh_token_type.lower() == "jwt":
         return JWTRefreshTokenUtil(
             secret_key=app_auth_jwt_token_secret_key,
-            algorithm=app_auth_jwt_token_algorithm
+            algorithm=app_auth_jwt_token_algorithm,
         )
-    raise ValueError(f'Invalid auth token type: {app_auth_refresh_token_type}')
+    raise ValueError(f"Invalid auth token type: {app_auth_refresh_token_type}")
 
 
 refresh_token_util = init_token_util()

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

@@ -1,10 +1,5 @@
-from component.log import logger
 from component.db_connection import engine
+from component.log import logger
+from module.auth.entity.group.repo import GroupDBRepo, GroupRepo
 
-from module.auth.entity.group.repo import (
-    GroupRepo, GroupDBRepo
-)
-
-group_repo: GroupRepo = GroupDBRepo(
-    logger=logger, engine=engine
-)
+group_repo: GroupRepo = GroupDBRepo(logger=logger, engine=engine)

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

@@ -1,9 +1,5 @@
-from component.log import logger
 from component.db_connection import engine
-from module.auth.entity.permission.repo import (
-    PermissionRepo, PermissionDBRepo
-)
+from component.log import logger
+from module.auth.entity.permission.repo import PermissionDBRepo, PermissionRepo
 
-permission_repo: PermissionRepo = PermissionDBRepo(
-    logger=logger, engine=engine
-)
+permission_repo: PermissionRepo = PermissionDBRepo(logger=logger, engine=engine)

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

@@ -1,9 +1,7 @@
-from module.auth.component.password_hasher import password_hasher
-from component.log import logger
 from component.db_connection import engine
-from module.auth.entity.user.repo import (
-    UserRepo, UserDBRepo
-)
+from component.log import logger
+from module.auth.component.password_hasher import password_hasher
+from module.auth.entity.user.repo import UserDBRepo, UserRepo
 
 user_repo: UserRepo = UserDBRepo(
     logger=logger, engine=engine, password_hasher=password_hasher