zrb 0.28.1__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/app/app.py

@@ -1,100 +0,0 @@
-from config import (
-    APP_AUTH_ACCESS_TOKEN_COOKIE_KEY,
-    APP_AUTH_REFRESH_TOKEN_COOKIE_KEY,
-    APP_BRAND,
-    APP_CORS_ALLOW_CREDENTIALS,
-    APP_CORS_ALLOW_HEADERS,
-    APP_CORS_ALLOW_METHODS,
-    APP_CORS_ALLOW_ORIGIN_REGEX,
-    APP_CORS_ALLOW_ORIGINS,
-    APP_CORS_EXPOSE_HEADERS,
-    APP_CORS_MAX_AGE,
-    APP_ENABLE_FRONTEND,
-    APP_NAME,
-    APP_TITLE,
-)
-from fastapi import FastAPI, status
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from integration.app.app_lifespan import app_lifespan
-from integration.app.app_state import app_state
-from integration.frontend_index import frontend_index_response
-from schema.frontend_config import FrontendConfig
-
-app = FastAPI(title=APP_NAME, lifespan=app_lifespan)
-
-if APP_ENABLE_FRONTEND:
-
-    @app.middleware("http")
-    async def catch_all(request, call_next):
-        response = await call_next(request)
-        if response.status_code != 404:
-            return response
-        api_error = str(response.headers.get("api-error", "")).lower() == "yes"
-        if api_error:
-            return response
-        return frontend_index_response
-
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=APP_CORS_ALLOW_ORIGINS,
-    allow_origin_regex=APP_CORS_ALLOW_ORIGIN_REGEX,
-    allow_methods=APP_CORS_ALLOW_METHODS,
-    allow_headers=APP_CORS_ALLOW_HEADERS,
-    allow_credentials=APP_CORS_ALLOW_CREDENTIALS,
-    expose_headers=APP_CORS_EXPOSE_HEADERS,
-    max_age=APP_CORS_MAX_AGE,
-)
-
-
-@app.head("/liveness")
-@app.get("/liveness")
-def get_application_liveness_status():
-    """
-    Get application liveness status.
-    Will return HTTP response status 200 if application is alive,
-    or return 503 otherwise.
-    Orchestrator like Kubernetes will restart
-    any application with non-healthy liveness status.
-    """
-    if app_state.get_liveness():
-        return JSONResponse(
-            content={"app": APP_NAME, "alive": True}, status_code=status.HTTP_200_OK
-        )
-    return JSONResponse(
-        content={"message": "Service is not alive"},
-        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-        headers={"api-error": "yes"},
-    )
-
-
-@app.head("/readiness")
-@app.get("/readiness")
-def get_application_readiness_status():
-    """
-    Get application readiness status.
-    Will return HTTP response status 200 if application is ready,
-    or return 503 otherwise.
-    Orchestrator like Kubernetes will only send user request
-    to any application with healthy readiness status.
-    """
-    if app_state.get_readiness():
-        return JSONResponse(
-            content={"app": APP_NAME, "ready": True}, status_code=status.HTTP_200_OK
-        )
-    return JSONResponse(
-        content={"message": "Service is not ready"},
-        status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
-        headers={"api-error": "yes"},
-    )
-
-
-@app.get("/api/v1/frontend/configs", response_model=FrontendConfig)
-def get_configs() -> FrontendConfig:
-    return FrontendConfig(
-        brand=APP_BRAND,
-        title=APP_TITLE,
-        access_token_cookie_key=APP_AUTH_ACCESS_TOKEN_COOKIE_KEY,
-        refresh_token_cookie_key=APP_AUTH_REFRESH_TOKEN_COOKIE_KEY,
-    )

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/app/app_lifespan.py

@@ -1,44 +0,0 @@
-import os
-from contextlib import asynccontextmanager
-
-from config import (
-    APP_DB_AUTO_MIGRATE,
-    APP_ENABLE_EVENT_HANDLER,
-    APP_ENABLE_FRONTEND,
-    APP_ENABLE_RPC_SERVER,
-    APP_NAME,
-    APP_SRC_DIR,
-)
-from fastapi import FastAPI
-from fastapi.staticfiles import StaticFiles
-from helper.async_task import create_task
-from integration.app.app_state import app_state, set_not_ready_on_error
-from integration.log import logger
-from integration.messagebus import consumer
-from integration.rpc import rpc_server
-from migrate import migrate
-
-
-@asynccontextmanager
-async def app_lifespan(app: FastAPI):
-    logger.info(f"{APP_NAME} started")
-    if APP_DB_AUTO_MIGRATE:
-        await migrate()
-    app_state.set_liveness(True)
-    if APP_ENABLE_EVENT_HANDLER:
-        create_task(consumer.start(), on_error=set_not_ready_on_error)
-    if APP_ENABLE_RPC_SERVER:
-        create_task(rpc_server.start(), on_error=set_not_ready_on_error)
-    if APP_ENABLE_FRONTEND:
-        build_path = os.path.join(APP_SRC_DIR, "frontend", "build")
-        app.mount(
-            path="",
-            app=StaticFiles(directory=build_path, html=True),
-            name="frontend-static-resources",
-        )
-    app_state.set_readiness(True)
-    logger.info(f"{APP_NAME} started")
-    yield
-    if APP_ENABLE_EVENT_HANDLER:
-        await consumer.stop()
-    logger.info(f"{APP_NAME} closed")

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/app/app_state.py

@@ -1,39 +0,0 @@
-import asyncio
-
-from config import APP_MAX_NOT_READY
-from integration.log import logger
-
-
-class AppState:
-    __instance = None
-
-    def __new__(cls):
-        if cls.__instance is None:
-            cls.__instance = super().__new__(cls)
-        return cls.__instance
-
-    def __init__(self):
-        self.readiness: bool = False
-        self.liveness: bool = False
-
-    def set_liveness(self, value: bool):
-        self.liveness = value
-
-    def set_readiness(self, value: bool):
-        self.readiness = value
-
-    def get_liveness(self) -> bool:
-        return self.liveness
-
-    def get_readiness(self) -> bool:
-        return self.readiness
-
-
-app_state = AppState()
-
-
-async def set_not_ready_on_error(exception: Exception):
-    logger.critical(exception)
-    app_state.set_readiness(False)
-    await asyncio.sleep(APP_MAX_NOT_READY)
-    app_state.set_liveness(False)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/db_connection.py

@@ -1,42 +0,0 @@
-import time
-
-from config import (
-    APP_DB_CONNECTION,
-    APP_DB_ENGINE_SHOW_LOG,
-    APP_DB_POOL_MAX_OVERFLOW,
-    APP_DB_POOL_PRE_PING,
-    APP_DB_POOL_SIZE,
-)
-from integration.log import logger
-from sqlalchemy import Engine, create_engine, event
-
-
-@event.listens_for(Engine, "before_cursor_execute")
-def before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
-    context._query_start_time = time.time()
-    one_line_statement = " ".join(statement.split("\n"))
-    logger.info(f"💽 [start query] SQL:`{one_line_statement}`, parameters {parameters}")
-
-
-@event.listens_for(Engine, "after_cursor_execute")
-def after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
-    total = time.time() - context._query_start_time
-    one_line_statement = " ".join(statement.split("\n"))
-    logger.info(
-        " ".join(
-            [
-                f"💽 [query completed] Elapsed time: {total} ms,",
-                f"SQL: `{one_line_statement}`,",
-                f"parameters {parameters}",
-            ]
-        )
-    )
-
-
-engine: Engine = create_engine(
-    APP_DB_CONNECTION,
-    echo=APP_DB_ENGINE_SHOW_LOG,
-    pool_pre_ping=APP_DB_POOL_PRE_PING,
-    pool_size=APP_DB_POOL_SIZE,
-    max_identifier_length=APP_DB_POOL_MAX_OVERFLOW,
-)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/frontend_index.py

@@ -1,10 +0,0 @@
-import os
-
-from config import APP_SRC_DIR
-from fastapi.responses import HTMLResponse
-
-index_html_path = os.path.join(APP_SRC_DIR, "frontend", "build", "index.html")
-with open(index_html_path, "r") as f:
-    index_html_content = f.read()
-
-frontend_index_response = HTMLResponse(content=index_html_content, status_code=200)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/log.py

@@ -1,45 +0,0 @@
-import logging
-
-from config import APP_ENABLE_OTEL, APP_LOGGING_LEVEL, APP_OTEL_EXPORTER_OTLP_ENDPOINT
-from opentelemetry._logs import set_logger_provider
-from opentelemetry.exporter.otlp.proto.grpc._log_exporter import OTLPLogExporter
-from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
-from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
-
-##############################################################################
-# Create logger
-##############################################################################
-logger = logging.getLogger("src")
-logger.setLevel(APP_LOGGING_LEVEL)
-
-##############################################################################
-# Formatter log handler
-##############################################################################
-
-stream_handler = logging.StreamHandler()
-stream_handler.setLevel(APP_LOGGING_LEVEL)
-# create formatter
-formatter = logging.Formatter("%(levelname)s:\t%(message)s")
-# set stream handler's formatter
-stream_handler.setFormatter(formatter)
-# add ch to logger
-logger.addHandler(stream_handler)
-
-##############################################################################
-# Open telemetry log handler
-##############################################################################
-
-if APP_ENABLE_OTEL:
-    # create logger providers
-    otlp_logger_provider = LoggerProvider()
-    # set the providers
-    set_logger_provider(otlp_logger_provider)
-    otlp_log_exporter = OTLPLogExporter(endpoint=APP_OTEL_EXPORTER_OTLP_ENDPOINT)
-    # add the batch processors to the trace provider
-    otlp_logger_provider.add_log_record_processor(
-        BatchLogRecordProcessor(otlp_log_exporter)
-    )
-    otlp_log_handler = LoggingHandler(
-        level=APP_LOGGING_LEVEL, logger_provider=otlp_logger_provider
-    )
-    logger.addHandler(otlp_log_handler)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/messagebus.py

@@ -1,113 +0,0 @@
-from component.messagebus import (
-    Admin,
-    Consumer,
-    KafkaAdmin,
-    KafkaConsumer,
-    KafkaPublisher,
-    MessageSerializer,
-    MockAdmin,
-    MockConsumer,
-    MockPublisher,
-    Publisher,
-    RMQAdmin,
-    RMQConsumer,
-    RMQPublisher,
-)
-from config import (
-    APP_BROKER_TYPE,
-    APP_KAFKA_BOOTSTRAP_SERVERS,
-    APP_KAFKA_SASL_MECHANISM,
-    APP_KAFKA_SASL_PASS,
-    APP_KAFKA_SASL_USER,
-    APP_KAFKA_SECURITY_PROTOCOL,
-    APP_NAME,
-    APP_RMQ_CONNECTION_STRING,
-)
-from integration.log import logger
-
-
-def init_admin(default_admin: Admin) -> Admin:
-    if APP_BROKER_TYPE == "rabbitmq":
-        return RMQAdmin(
-            logger=logger, connection_string=APP_RMQ_CONNECTION_STRING, configs={}
-        )
-    if APP_BROKER_TYPE == "kafka":
-        return KafkaAdmin(
-            logger=logger,
-            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
-            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
-            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
-            sasl_plain_username=APP_KAFKA_SASL_USER,
-            sasl_plain_password=APP_KAFKA_SASL_PASS,
-            configs={},
-        )
-    return default_admin
-
-
-def init_publisher(
-    serializer: MessageSerializer, admin: Admin, default_publisher: Publisher
-) -> Publisher:
-    if APP_BROKER_TYPE == "rabbitmq":
-        return RMQPublisher(
-            logger=logger,
-            connection_string=APP_RMQ_CONNECTION_STRING,
-            serializer=serializer,
-            rmq_admin=admin,
-        )
-    if APP_BROKER_TYPE == "kafka":
-        return KafkaPublisher(
-            logger=logger,
-            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
-            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
-            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
-            sasl_plain_username=APP_KAFKA_SASL_USER,
-            sasl_plain_password=APP_KAFKA_SASL_PASS,
-            serializer=serializer,
-            kafka_admin=admin,
-        )
-    return default_publisher
-
-
-def init_consumer(
-    serializer: MessageSerializer, admin: Admin, default_consumer: Consumer
-) -> Consumer:
-    if APP_BROKER_TYPE == "rabbitmq":
-        return RMQConsumer(
-            logger=logger,
-            connection_string=APP_RMQ_CONNECTION_STRING,
-            serializer=serializer,
-            rmq_admin=admin,
-        )
-    if APP_BROKER_TYPE == "kafka":
-        return KafkaConsumer(
-            logger=logger,
-            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
-            security_protocol=APP_KAFKA_SECURITY_PROTOCOL,
-            sasl_mechanism=APP_KAFKA_SASL_MECHANISM,
-            sasl_plain_username=APP_KAFKA_SASL_USER,
-            sasl_plain_password=APP_KAFKA_SASL_PASS,
-            group_id=APP_NAME,
-            serializer=serializer,
-            kafka_admin=admin,
-        )
-    return default_consumer
-
-
-def init_message_serializer() -> MessageSerializer:
-    # Add custom logic if necessary
-    return MessageSerializer()
-
-
-message_serializer = init_message_serializer()
-mock_admin = MockAdmin()
-mock_consumer = MockConsumer(logger=logger, serializer=message_serializer)
-mock_publisher = MockPublisher(
-    logger=logger, consumer=mock_consumer, serializer=message_serializer
-)
-admin = init_admin(default_admin=mock_admin)
-consumer = init_consumer(
-    serializer=message_serializer, admin=admin, default_consumer=mock_consumer
-)
-publisher = init_publisher(
-    serializer=message_serializer, admin=admin, default_publisher=mock_publisher
-)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/integration/rpc.py

@@ -1,49 +0,0 @@
-from component.messagebus import KafkaConsumer, RMQConsumer
-from component.rpc import Caller, MessagebusCaller, MessagebusServer, Server
-from config import (
-    APP_BROKER_TYPE,
-    APP_KAFKA_BOOTSTRAP_SERVERS,
-    APP_NAME,
-    APP_RMQ_CONNECTION_STRING,
-)
-from integration.log import logger
-from integration.messagebus import (
-    admin,
-    consumer,
-    message_serializer,
-    mock_consumer,
-    publisher,
-)
-from ulid import ULID
-
-
-def create_consumer():
-    if APP_BROKER_TYPE == "rabbitmq":
-        return RMQConsumer(
-            logger=logger,
-            connection_string=APP_RMQ_CONNECTION_STRING,
-            serializer=message_serializer,
-            rmq_admin=admin,
-            identifier="rmq-rpc-reply-consumer",
-        )
-    if APP_BROKER_TYPE == "kafka":
-        random_uuid = str(ULID())
-        group_id = f"{APP_NAME}-reply-{random_uuid}"
-        return KafkaConsumer(
-            logger=logger,
-            bootstrap_servers=APP_KAFKA_BOOTSTRAP_SERVERS,
-            group_id=group_id,
-            serializer=message_serializer,
-            kafka_admin=admin,
-            identifier="kafka-rpc-reply-consumer",
-        )
-    return mock_consumer
-
-
-rpc_caller: Caller = MessagebusCaller(
-    logger=logger, admin=admin, publisher=publisher, consumer_factory=create_consumer
-)
-
-rpc_server: Server = MessagebusServer(
-    logger=logger, consumer=consumer, publisher=publisher
-)

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/main.py

@@ -1,7 +0,0 @@
-from integration.app.app import app
-from module.auth.register_module import register_auth
-from module.log.register_module import register_log
-
-assert app
-register_auth()
-register_log()

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

@@ -1,13 +0,0 @@
-import asyncio
-
-from module.auth.migrate import migrate_auth
-from module.log.migrate import migrate_log
-
-
-async def migrate():
-    await migrate_auth()
-    await migrate_log()
-
-
-if __name__ == "__main__":
-    asyncio.run(migrate())

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

@@ -1,24 +0,0 @@
-from logging import Logger
-
-from component.messagebus import Publisher
-from component.rpc import Caller
-from fastapi import FastAPI
-from module.auth.component import Authorizer
-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(
-    logger: Logger,
-    app: FastAPI,
-    authorizer: Authorizer,
-    rpc_caller: Caller,
-    publisher: Publisher,
-):
-    logger.info('🥪 Register API for "auth"')
-    register_user_login_api(logger, app, authorizer, rpc_caller, publisher)
-    register_permission_api(logger, app, authorizer, rpc_caller, publisher)
-    register_group_api(logger, app, authorizer, rpc_caller, publisher)
-    register_user_api(logger, app, authorizer, rpc_caller, publisher)

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

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

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/component/access_token/scheme.py

@@ -1,34 +0,0 @@
-from collections.abc import Callable
-from typing import Optional
-
-from fastapi import Depends
-from fastapi.security import OAuth2PasswordBearer
-from module.auth.component.access_token.util import AccessTokenUtil
-from module.auth.schema.token import AccessTokenData
-from module.auth.schema.user import User
-from starlette.requests import Request
-
-AccessTokenScheme = Callable[[Request], AccessTokenData]
-
-
-def create_oauth2_bearer_access_token_scheme(
-    guest_user: User,
-    access_token_util: AccessTokenUtil,
-    token_url: str,
-    token_cookie_key: str,
-) -> AccessTokenScheme:
-    oauth2_scheme = OAuth2PasswordBearer(tokenUrl=token_url, auto_error=False)
-
-    async def oauth2_bearer_token_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
-            )
-        return access_token_util.decode(token, parse_expired_token=False)
-
-    return oauth2_bearer_token_scheme

zrb/builtin/project/add/fastapp/app/template/src/kebab-zrb-app-name/src/module/auth/component/access_token/util.py

@@ -1,60 +0,0 @@
-from abc import ABC, abstractmethod
-from collections.abc import Mapping
-from datetime import datetime, timedelta
-from typing import Any
-
-import jsons
-from component.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
-
-    @abstractmethod
-    def decode(
-        self, token_str: str, parse_expired_token: bool = False
-    ) -> AccessTokenData:
-        pass
-
-
-class JWTAccessTokenUtil(AccessTokenUtil):
-    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.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:
-        try:
-            decoded_data = jwt.decode(
-                token,
-                self.secret_key,
-                algorithms=[self.algorithm],
-                options=self._get_decode_options(parse_expired_token),
-            )
-            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 = (
-                    datetime.fromtimestamp(expire_time) - datetime.utcnow()
-                ).total_seconds()
-                if token_data.expire_seconds < 0:
-                    raise HTTPAPIException(422, "Expired token")
-            return token_data
-        except jwt.JWTError:
-            raise HTTPAPIException(422, "Invalid token")
-
-    def _get_decode_options(self, parse_expired_token: bool) -> Mapping[str, Any]:
-        if parse_expired_token:
-            return {"verify_exp": False}
-        return {}

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

@@ -1,15 +0,0 @@
-from abc import ABC, abstractmethod
-
-
-class Authorizer(ABC):
-    @abstractmethod
-    async def is_admin(self, user_id: str) -> bool:
-        pass
-
-    @abstractmethod
-    async def is_guest(self, user_id: str) -> bool:
-        pass
-
-    @abstractmethod
-    async def is_having_permission(self, user_id: str, *permission_names: str) -> bool:
-        pass

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

@@ -1,33 +0,0 @@
-from component.rpc import Caller
-from module.auth.component.authorizer.authorizer import Authorizer
-
-
-class RPCAuthorizer(Authorizer):
-    def __init__(
-        self,
-        rpc_caller: Caller,
-        is_admin_rpc_name: str,
-        is_guest_rpc_name: str,
-        is_user_authorized_rpc_name: str,
-    ):
-        self.rpc_caller = rpc_caller
-        self.is_admin_rpc_name = is_admin_rpc_name
-        self.is_guest_rpc_name = is_guest_rpc_name
-        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)
-
-    async def is_guest(self, user_id: str) -> bool:
-        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:
-        permission_map = await self.rpc_caller.call(
-            self.is_user_authorized_rpc_name,
-            id=user_id,
-            permission_name=permission_name,
-        )
-        for permission in permission_map:
-            if not permission_map[permission]:
-                return False
-        return True

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

@@ -1,10 +0,0 @@
-import bcrypt
-from module.auth.component.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")
-
-    def check_password(self, password: str, hashed_password: str) -> bool:
-        return bcrypt.checkpw(password.encode("utf-8"), hashed_password.encode("utf-8"))