zrb 1.0.0a20__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/common/base_usecase.py

@@ -1,245 +0,0 @@
-from enum import Enum
-from functools import partial, wraps
-from typing import Any, Callable, Sequence
-
-import httpx
-from fastapi import APIRouter, params
-from fastapi.routing import APIRoute
-from fastapi.types import IncEx
-from fastapi.utils import generate_unique_id
-from starlette.responses import JSONResponse, Response
-
-
-class RouteParam:
-    def __init__(
-        self,
-        path: str,
-        response_model: Any,
-        status_code: int | None = None,
-        tags: list[str | Enum] | None = None,
-        dependencies: Sequence[params.Depends] | None = None,
-        summary: str | None = None,
-        description: str = "",
-        response_description: str = "",
-        responses: dict[int | str, dict[str, Any]] | None = None,
-        deprecated: bool | None = None,
-        methods: set[str] | list[str] | None = None,
-        operation_id: str | None = None,
-        response_model_include: IncEx | None = None,
-        response_model_exclude: IncEx | None = None,
-        response_model_by_alias: bool = True,
-        response_model_exclude_unset: bool = False,
-        response_model_exclude_defaults: bool = False,
-        response_model_exclude_none: bool = False,
-        include_in_schema: bool = True,
-        response_class: type[Response] = Response,
-        name: str | None = None,
-        openapi_extra: dict[str, Any] | None = None,
-        generate_unique_id_function: Callable[[APIRoute], str] | None = None,
-        func: Callable | None = None,
-    ):
-        self.path = path
-        self.response_model = response_model
-        self.status_code = status_code
-        self.tags = tags
-        self.dependencies = dependencies
-        self.summary = summary
-        self.description = description
-        self.response_description = response_description
-        self.responses = responses
-        self.deprecated = deprecated
-        self.methods = methods
-        self.operation_id = operation_id
-        self.response_model_include = response_model_include
-        self.response_model_exclude = response_model_exclude
-        self.response_model_by_alias = response_model_by_alias
-        self.response_model_exclude_unset = response_model_exclude_unset
-        self.response_model_exclude_defaults = response_model_exclude_defaults
-        self.response_model_exclude_none = response_model_exclude_none
-        self.include_in_schema = include_in_schema
-        self.response_class = response_class
-        self.name = name
-        self.openapi_extra = openapi_extra
-        self.generate_unique_id_function = generate_unique_id_function
-        self.func = func
-
-
-class BaseUsecase:
-    _route_params: dict[str, RouteParam] = {}
-
-    def __init__(self):
-        self._route_params: dict[str, RouteParam] = {}
-        for name, method in self.__class__.__dict__.items():
-            if hasattr(method, "__route_param__"):
-                self._route_params[name] = getattr(method, "__route_param__")
-
-    @classmethod
-    def route(
-        cls,
-        path: str,
-        *,
-        response_model: Any = None,
-        status_code: int | None = None,
-        tags: list[str | Enum] | None = None,
-        dependencies: Sequence[params.Depends] | None = None,
-        summary: str | None = None,
-        description: str = None,
-        response_description: str = "Successful Response",
-        responses: dict[int | str, dict[str, Any]] | None = None,
-        deprecated: bool | None = None,
-        methods: set[str] | list[str] | None = None,
-        operation_id: str | None = None,
-        response_model_include: IncEx | None = None,
-        response_model_exclude: IncEx | None = None,
-        response_model_by_alias: bool = True,
-        response_model_exclude_unset: bool = False,
-        response_model_exclude_defaults: bool = False,
-        response_model_exclude_none: bool = False,
-        include_in_schema: bool = True,
-        response_class: type[Response] = JSONResponse,
-        name: str | None = None,
-        openapi_extra: dict[str, Any] | None = None,
-        generate_unique_id_function: Callable[[APIRoute], str] = generate_unique_id,
-    ):
-        """
-        Decorator to register a method with its HTTP details.
-        """
-
-        def decorator(func: Callable):
-            @wraps(func)
-            async def wrapped(*args, **kwargs):
-                return await func(*args, **kwargs)
-
-            # Inject __route_param__ property to the method
-            # Method with __route_param__ property will automatically
-            # registered to self._route_param and will be automatically exposed
-            # into DirectClient and APIClient
-            wrapped.__route_param__ = RouteParam(
-                path=path,
-                response_model=response_model,
-                status_code=status_code,
-                tags=tags,
-                dependencies=dependencies,
-                summary=summary,
-                description=description,
-                response_description=response_description,
-                responses=responses,
-                deprecated=deprecated,
-                methods=methods,
-                operation_id=operation_id,
-                response_model_include=response_model_include,
-                response_model_exclude=response_model_exclude,
-                response_model_by_alias=response_model_by_alias,
-                response_model_exclude_unset=response_model_exclude_unset,
-                response_model_exclude_defaults=response_model_exclude_defaults,
-                response_model_exclude_none=response_model_exclude_none,
-                include_in_schema=include_in_schema,
-                response_class=response_class,
-                name=name,
-                openapi_extra=openapi_extra,
-                generate_unique_id_function=generate_unique_id_function,
-                func=func,
-            )
-            return wrapped
-
-        return decorator
-
-    def as_direct_client(self):
-        """
-        Dynamically create a direct client class.
-        """
-        _methods = self._route_params
-        DirectClient = create_client_class("DirectClient")
-        for name, details in _methods.items():
-            func = details.func
-            client_method = create_direct_client_method(func, self)
-            # Use __get__ to make a bounded method,
-            # ensuring that client_method use DirectClient as `self`
-            setattr(DirectClient, name, client_method.__get__(DirectClient))
-        return DirectClient
-
-    def as_api_client(self, base_url: str):
-        """
-        Dynamically create an API client class.
-        """
-        _methods = self._route_params
-        APIClient = create_client_class("APIClient")
-        # Dynamically generate methods
-        for name, param in _methods.items():
-            client_method = create_api_client_method(param, base_url)
-            # Use __get__ to make a bounded method,
-            # ensuring that client_method use APIClient as `self`
-            setattr(APIClient, name, client_method.__get__(APIClient))
-        return APIClient
-
-    def serve_route(self, app: APIRouter):
-        """
-        Dynamically add routes to FastAPI.
-        """
-        for _, route_param in self._route_params.items():
-            bound_func = partial(route_param.func, self)
-            bound_func.__name__ = route_param.func.__name__
-            bound_func.__doc__ = route_param.func.__doc__
-            app.add_api_route(
-                path=route_param.path,
-                endpoint=bound_func,
-                response_model=route_param.response_model,
-                status_code=route_param.status_code,
-                tags=route_param.tags,
-                dependencies=route_param.dependencies,
-                summary=route_param.summary,
-                description=route_param.description,
-                response_description=route_param.response_description,
-                responses=route_param.responses,
-                deprecated=route_param.deprecated,
-                methods=route_param.methods,
-                operation_id=route_param.operation_id,
-                response_model_include=route_param.response_model_include,
-                response_model_exclude=route_param.response_model_exclude,
-                response_model_by_alias=route_param.response_model_by_alias,
-                response_model_exclude_unset=route_param.response_model_exclude_unset,
-                response_model_exclude_defaults=route_param.response_model_exclude_defaults,
-                response_model_exclude_none=route_param.response_model_exclude_none,
-                include_in_schema=route_param.include_in_schema,
-                response_class=route_param.response_class,
-                name=route_param.name,
-                openapi_extra=route_param.openapi_extra,
-                generate_unique_id_function=route_param.generate_unique_id_function,
-            )
-
-
-def create_client_class(name):
-    class Client:
-        pass
-
-    Client.__name__ = name
-    return Client
-
-
-def create_direct_client_method(func: Callable, usecase: BaseUsecase):
-    async def client_method(self, *args, **kwargs):
-        return await func(usecase, *args, **kwargs)
-
-    return client_method
-
-
-def create_api_client_method(param: RouteParam, base_url: str):
-    _url = param.path
-    _methods = [method.lower() for method in param.methods]
-
-    async def client_method(self, *args, **kwargs):
-        async with httpx.AsyncClient() as client:
-            url = base_url + _url.format(**kwargs)
-            if "post" in _methods:
-                response = await client.post(url, json=kwargs)
-            elif "put" in _methods:
-                response = await client.put(url, json=kwargs)
-            elif "delete" in _methods:
-                response = await client.delete(url, json=kwargs)
-            else:
-                response = await client.get(url, params=kwargs)
-            # Add more HTTP methods as needed
-            response.raise_for_status()
-            return response.json()
-
-    return client_method

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/any_client.py

@@ -1,33 +0,0 @@
-from abc import ABC, abstractmethod
-
-from my_app_name.schema.user import (
-    UserCreateWithAudit,
-    UserResponse,
-    UserUpdateWithAudit,
-)
-
-
-class AnyClient(ABC):
-    @abstractmethod
-    async def get_user_by_id(self, user_id: str) -> UserResponse:
-        pass
-
-    @abstractmethod
-    async def get_all_users(self) -> list[UserResponse]:
-        pass
-
-    @abstractmethod
-    async def create_user(
-        self, data: UserCreateWithAudit | list[UserCreateWithAudit]
-    ) -> UserResponse | list[UserResponse]:
-        pass
-
-    @abstractmethod
-    async def update_user(
-        self, user_id: str, data: UserUpdateWithAudit
-    ) -> UserResponse:
-        pass
-
-    @abstractmethod
-    async def delete_user(self, user_id: str) -> UserResponse:
-        pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/api_client.py

@@ -1,7 +0,0 @@
-from my_app_name.config import APP_AUTH_BASE_URL
-from my_app_name.module.auth.client.any_client import AnyClient
-from my_app_name.module.auth.service.user.user_usecase_factory import user_usecase
-
-
-class APIClient(user_usecase.as_api_client(base_url=APP_AUTH_BASE_URL), AnyClient):
-    pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/direct_client.py

@@ -1,6 +0,0 @@
-from my_app_name.module.auth.client.any_client import AnyClient
-from my_app_name.module.auth.service.user.user_usecase_factory import user_usecase
-
-
-class DirectClient(user_usecase.as_direct_client(), AnyClient):
-    pass

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/client/factory.py

@@ -1,9 +0,0 @@
-from my_app_name.config import APP_COMMUNICATION
-from my_app_name.module.auth.client.any_client import AnyClient
-from my_app_name.module.auth.client.api_client import APIClient
-from my_app_name.module.auth.client.direct_client import DirectClient
-
-if APP_COMMUNICATION == "direct":
-    client: AnyClient = DirectClient()
-elif APP_COMMUNICATION == "api":
-    client: AnyClient = APIClient()

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/migration/versions/3093c7336477_add_user_table.py

@@ -1,37 +0,0 @@
-"""Add user table
-
-Revision ID: 3093c7336477
-Revises:
-Create Date: 2024-11-20 05:57:01.684118
-
-"""
-
-from typing import Sequence, Union
-
-import sqlalchemy as sa
-import sqlmodel
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "3093c7336477"
-down_revision: Union[str, None] = None
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.create_table(
-        "user",
-        sa.Column("id", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.Column("username", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.Column("password", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
-        sa.PrimaryKeyConstraint("id"),
-    )
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.drop_table("user")
-    # ### end Alembic commands ###

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_usecase.py

@@ -1,53 +0,0 @@
-from my_app_name.common.base_usecase import BaseUsecase
-from my_app_name.module.auth.service.user.repository.user_repository import (
-    UserRepository,
-)
-from my_app_name.schema.user import (
-    UserCreateWithAudit,
-    UserResponse,
-    UserUpdateWithAudit,
-)
-
-
-class UserUsecase(BaseUsecase):
-    def __init__(self, user_repository: UserRepository):
-        super().__init__()
-        self.user_repository = user_repository
-
-    @BaseUsecase.route(
-        "/api/v1/users/{user_id}", methods=["get"], response_model=UserResponse
-    )
-    async def get_user_by_id(self, user_id: str) -> UserResponse:
-        return await self.user_repository.get_by_id(user_id)
-
-    @BaseUsecase.route(
-        "/api/v1/users", methods=["get"], response_model=list[UserResponse]
-    )
-    async def get_all_users(self) -> list[UserResponse]:
-        return await self.user_repository.get_all()
-
-    @BaseUsecase.route(
-        "/api/v1/users",
-        methods=["post"],
-        response_model=UserResponse | list[UserResponse],
-    )
-    async def create_user(
-        self, data: UserCreateWithAudit | list[UserCreateWithAudit]
-    ) -> UserResponse | list[UserResponse]:
-        if isinstance(data, UserCreateWithAudit):
-            return await self.user_repository.create(data)
-        return await self.user_repository.create_bulk(data)
-
-    @BaseUsecase.route(
-        "/api/v1/users/{user_id}", methods=["put"], response_model=UserResponse
-    )
-    async def update_user(
-        self, user_id: str, data: UserUpdateWithAudit
-    ) -> UserResponse:
-        return await self.user_repository.update(user_id, data)
-
-    @BaseUsecase.route(
-        "/api/v1/users/{user_id}", methods=["delete"], response_model=UserResponse
-    )
-    async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
-        return await self.user_repository.delete(user_id)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_usecase_factory.py

@@ -1,6 +0,0 @@
-from my_app_name.module.auth.service.user.repository.user_repository_factory import (
-    user_repository,
-)
-from my_app_name.module.auth.service.user.user_usecase import UserUsecase
-
-user_usecase = UserUsecase(user_repository=user_repository)

zrb/runner/web_config.py

@@ -1,288 +0,0 @@
-from datetime import datetime, timedelta
-from typing import TYPE_CHECKING, Callable
-
-from pydantic import BaseModel, ConfigDict
-
-from zrb.config import (
-    WEB_ACCESS_TOKEN_COOKIE_NAME,
-    WEB_AUTH_ACCESS_TOKEN_EXPIRE_MINUTES,
-    WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES,
-    WEB_ENABLE_AUTH,
-    WEB_GUEST_USERNAME,
-    WEB_HTTP_PORT,
-    WEB_REFRESH_TOKEN_COOKIE_NAME,
-    WEB_SECRET_KEY,
-    WEB_SUPER_ADMIN_PASSWORD,
-    WEB_SUPER_ADMIN_USERNAME,
-)
-from zrb.group.any_group import AnyGroup
-from zrb.task.any_task import AnyTask
-from zrb.util.group import get_all_subtasks
-
-if TYPE_CHECKING:
-    # Import Request only for type checking to reduce runtime dependencies
-    from fastapi import Request
-
-
-class User(BaseModel):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-    username: str
-    password: str = ""
-    is_super_admin: bool = False
-    is_guest: bool = False
-    accessible_tasks: list[AnyTask | str] = []
-
-    def is_password_match(self, password: str) -> bool:
-        return self.password == password
-
-    def can_access_group(self, group: AnyGroup) -> bool:
-        if self.is_super_admin:
-            return True
-        all_tasks = get_all_subtasks(group, web_only=True)
-        if any(self.can_access_task(task) for task in all_tasks):
-            return True
-        return False
-
-    def can_access_task(self, task: AnyTask) -> bool:
-        if self.is_super_admin:
-            return True
-        if task.name in self.accessible_tasks or task in self.accessible_tasks:
-            return True
-        return False
-
-
-class Token(BaseModel):
-    access_token: str
-    refresh_token: str
-    token_type: str
-
-
-class WebConfig:
-    def __init__(
-        self,
-        port: int,
-        secret_key: str,
-        access_token_expire_minutes: int,
-        refresh_token_expire_minutes: int,
-        access_token_cookie_name: str,
-        refresh_token_cookie_name: str,
-        enable_auth: bool,
-        super_admin_username: str,
-        super_admin_password: str,
-        guest_username: str,
-        guest_accessible_tasks: list[AnyTask | str] = [],
-        find_user_by_username: Callable[[str], User | None] | None = None,
-    ):
-        self._secret_key = secret_key
-        self._access_token_expire_minutes = access_token_expire_minutes
-        self._refresh_token_expire_minutes = refresh_token_expire_minutes
-        self._access_token_cookie_name = access_token_cookie_name
-        self._refresh_token_cookie_name = refresh_token_cookie_name
-        self._enable_auth = enable_auth
-        self._port = port
-        self._user_list = []
-        self._super_admin_username = super_admin_username
-        self._super_admin_password = super_admin_password
-        self._guest_username = guest_username
-        self._guest_accessible_tasks = guest_accessible_tasks
-        self._find_user_by_username = find_user_by_username
-
-    @property
-    def port(self) -> int:
-        return self._port
-
-    @property
-    def access_token_cookie_name(self) -> str:
-        return self._access_token_cookie_name
-
-    @property
-    def refresh_token_cookie_name(self) -> str:
-        return self._refresh_token_cookie_name
-
-    @property
-    def access_token_max_age(self) -> int:
-        self._access_token_expire_minutes * 60
-
-    @property
-    def refresh_token_max_age(self) -> int:
-        self._refresh_token_expire_minutes * 60
-
-    @property
-    def default_user(self) -> User:
-        if self._enable_auth:
-            return User(
-                username=self._guest_username,
-                password="",
-                is_guest=True,
-                accessible_tasks=self._guest_accessible_tasks,
-            )
-        return User(
-            username=self._guest_username,
-            password="",
-            is_guest=True,
-            is_super_admin=True,
-        )
-
-    @property
-    def super_admin(self) -> User:
-        return User(
-            username=self._super_admin_username,
-            password=self._super_admin_password,
-            is_super_admin=True,
-        )
-
-    @property
-    def user_list(self) -> list[User]:
-        if not self._enable_auth:
-            return [self.default_user]
-        return self._user_list + [self.super_admin, self.default_user]
-
-    def set_guest_accessible_tasks(self, tasks: list[AnyTask | str]):
-        self._guest_accessible_tasks = tasks
-
-    def set_find_user_by_username(
-        self, find_user_by_username: Callable[[str], User | None]
-    ):
-        self._find_user_by_username = find_user_by_username
-
-    def append_user(self, user: User):
-        duplicates = [
-            existing_user
-            for existing_user in self.user_list
-            if existing_user.username == user.username
-        ]
-        if len(duplicates) > 0:
-            raise ValueError(f"User already exists {user.username}")
-        self._user_list.append(user)
-
-    def enable_auth(self):
-        self._enable_auth = True
-
-    def disable_auth(self):
-        self._enable_auth = False
-
-    def find_user_by_username(self, username: str) -> User | None:
-        user = None
-        if self._find_user_by_username is not None:
-            user = self._find_user_by_username(username)
-        if user is None:
-            user = next((u for u in self.user_list if u.username == username), None)
-        return user
-
-    async def get_user_by_request(self, request: "Request") -> User | None:
-        from fastapi.security import OAuth2PasswordBearer
-
-        if not self._enable_auth:
-            return self.default_user
-        # Normally we use "Depends"
-        get_bearer_token = OAuth2PasswordBearer(
-            tokenUrl="/api/v1/login", auto_error=False
-        )
-        bearer_token = await get_bearer_token(request)
-        token_user = self._get_user_from_token(bearer_token)
-        if token_user is not None:
-            return token_user
-        cookie_user = self._get_user_from_cookie(request)
-        if cookie_user is not None:
-            return cookie_user
-        return self.default_user
-
-    def _get_user_from_token(self, token: str) -> User | None:
-        try:
-            from jose import jwt
-
-            payload = jwt.decode(
-                token,
-                self._secret_key,
-                options={"require_sub": True, "require_exp": True},
-            )
-            username: str = payload.get("sub")
-            if username is None:
-                return None
-            user = self.find_user_by_username(username)
-            if user is None:
-                return None
-            return user
-        except Exception:
-            return None
-
-    def _get_user_from_cookie(self, request: "Request") -> User | None:
-        token = request.cookies.get(self._access_token_cookie_name)
-        if token:
-            return self._get_user_from_token(token)
-        return None
-
-    def get_user_by_credentials(self, username: str, password: str) -> User:
-        user = self.find_user_by_username(username)
-        if user is None or not user.is_password_match(password):
-            return self.default_user
-        return user
-
-    def generate_tokens(self, username: str, password: str) -> Token:
-        if not self._enable_auth:
-            user = self.default_user
-        else:
-            user = self.get_user_by_credentials(username, password)
-        access_token = self.create_access_token(user.username)
-        refresh_token = self.create_refresh_token(user.username)
-        return Token(
-            access_token=access_token, refresh_token=refresh_token, token_type="bearer"
-        )
-
-    def create_access_token(self, username: str) -> str:
-        from jose import jwt
-
-        expire = datetime.now() + timedelta(minutes=self._access_token_expire_minutes)
-        to_encode = {"sub": username, "exp": expire, "type": "access"}
-        return jwt.encode(to_encode, self._secret_key)
-
-    def create_refresh_token(self, username: str) -> str:
-        from jose import jwt
-
-        expire = datetime.now() + timedelta(minutes=self._refresh_token_expire_minutes)
-        to_encode = {"sub": username, "exp": expire, "type": "refresh"}
-        return jwt.encode(to_encode, self._secret_key)
-
-    def refresh_tokens(self, refresh_token: str) -> Token:
-        from fastapi import HTTPException
-        from jose import jwt
-
-        # Decode and validate token
-        try:
-            payload = jwt.decode(
-                refresh_token,
-                self._secret_key,
-                options={"require_exp": True, "require_sub": True},
-            )
-        except Exception:
-            raise HTTPException(status_code=401, detail="Invalid JWT token")
-        if payload.get("type") != "refresh":
-            raise HTTPException(status_code=401, detail="Invalid token type")
-        username: str = payload.get("sub")
-        if username is None:
-            raise HTTPException(status_code=401, detail="Invalid refresh token")
-        user = self.find_user_by_username(username)
-        if user is None:
-            raise HTTPException(status_code=401, detail="User not found")
-        # Create new token
-        new_access_token = self.create_access_token(username)
-        new_refresh_token = self.create_refresh_token(username)
-        return Token(
-            access_token=new_access_token,
-            refresh_token=new_refresh_token,
-            token_type="bearer",
-        )
-
-
-web_config = WebConfig(
-    port=WEB_HTTP_PORT,
-    secret_key=WEB_SECRET_KEY,
-    access_token_expire_minutes=WEB_AUTH_ACCESS_TOKEN_EXPIRE_MINUTES,
-    refresh_token_expire_minutes=WEB_AUTH_REFRESH_TOKEN_EXPIRE_MINUTES,
-    access_token_cookie_name=WEB_ACCESS_TOKEN_COOKIE_NAME,
-    refresh_token_cookie_name=WEB_REFRESH_TOKEN_COOKIE_NAME,
-    enable_auth=WEB_ENABLE_AUTH,
-    super_admin_username=WEB_SUPER_ADMIN_USERNAME,
-    super_admin_password=WEB_SUPER_ADMIN_PASSWORD,
-    guest_username=WEB_GUEST_USERNAME,
-)