FastAPI-fastkit 0.1.0__py3-none-any.whl

fastapi_fastkit/fastapi_project_template/fastapi-default/src/crud/_base.py-tpl

@@ -0,0 +1,92 @@
+# --------------------------------------------------------------------------
+# The module defines basic Model CRUD methods.
+# --------------------------------------------------------------------------
+from __future__ import annotations
+
+import json
+
+from typing import Any, Type, List, Optional
+
+from pydantic import BaseModel
+from sqlalchemy import select, text
+from sqlalchemy.ext.asyncio import AsyncSession
+
+
+def load_json(file_path: str):
+    with open(file_path, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+
+async def get_object(
+    db: AsyncSession, model: Any, model_id: int | str, response_model: Type[BaseModel]
+) -> Optional[Any]:
+    result = await db.get(model, model_id)
+    return response_model.model_validate(result.__dict__)
+
+
+async def get_object_with_uuid(
+    db: AsyncSession, model: Any, model_uid: str, response_model: Type[BaseModel]
+) -> Optional[Any]:
+    result = await db.get(model, model_uid)
+    return response_model.model_validate(result.__dict__)
+
+
+async def get_objects(
+    db: AsyncSession,
+    model: Any,
+    response_model: Type[BaseModel],
+    condition: Optional[Any] = None,
+    skip: int = 0,
+    limit: int = 100,
+) -> List[Any]:
+    query = select(model).offset(skip).limit(limit)
+    if condition is not None:
+        query = query.where(text(condition))
+    result = await db.execute(query)
+    result_list = result.scalars().all()
+    return [response_model.model_validate(item.__dict__) for item in result_list]
+
+
+async def create_object(
+    db: AsyncSession, model: Any, obj: BaseModel, response_model: Type[BaseModel]
+) -> Any:
+    obj_data = obj.model_dump()
+    db_obj = model(**obj_data)
+
+    db.add(db_obj)
+    await db.commit()
+    await db.refresh(db_obj)
+    return response_model.model_validate(db_obj.__dict__)
+
+
+async def update_object(
+    db: AsyncSession,
+    model: Any,
+    model_id: int | str,
+    obj: BaseModel,
+    response_model: Type[BaseModel],
+) -> Optional[Any]:
+    query = select(model).filter(model.id == model_id)
+    db_obj = (await db.execute(query)).scalar_one_or_none()
+    if db_obj is None:
+        return None
+    update_data = obj.model_dump(exclude_unset=True)
+    for key, value in update_data.items():
+        setattr(db_obj, key, value)
+    db.add(db_obj)
+    await db.commit()
+    await db.refresh(db_obj)
+    return response_model.model_validate(db_obj.__dict__)
+
+
+async def delete_object(
+    db: AsyncSession, model: Any, model_id: int | str
+) -> Optional[int]:
+    query = select(model).filter(model.id == model_id)
+    db_obj = (await db.execute(query)).scalar_one_or_none()
+    if db_obj:
+        await db.delete(db_obj)
+        await db.commit()
+    else:
+        return None
+    return model_id

fastapi_fastkit/fastapi_project_template/fastapi-default/src/crud/user.py-tpl

@@ -0,0 +1,44 @@
+# --------------------------------------------------------------------------
+# The module defines User model's CRUD methods.
+# --------------------------------------------------------------------------
+import os
+
+from typing import Type
+from uuid import UUID
+
+from ._base import load_json
+from src.helper.exceptions import InternalException, ErrorCode
+from src.schemas.user import UserSchema, UserCreate, UserUpdate
+from src.helper.global_data import mock_user_data
+
+
+def get_mock_user_data(id: UUID) -> dict:
+    user_data = next((user for user in mock_user_data if user["id"] == str(id)), None)
+    if user_data is None:
+        raise InternalException(
+            message="User not found.", error_code=ErrorCode.NOT_FOUND
+        )
+    return user_data
+
+
+def create_mock_user(user: UserCreate) -> dict:
+    new_user = user.model_dump()
+    if any(u["email"] == new_user["email"] for u in mock_user_data):
+        raise InternalException(
+            error_code=ErrorCode.CONFLICT,
+            message="This user is already exist.",
+        )
+    mock_user_data.append(new_user)
+    return new_user
+
+
+def update_mock_user(id: UUID, user: UserUpdate) -> dict:
+    user_data = get_mock_user_data(id)
+    update_data = user.model_dump(exclude_unset=True)
+    user_data.update(update_data)
+    return user_data
+
+
+def delete_mock_user(id: UUID) -> None:
+    user_data = get_mock_user_data(id)
+    mock_user_data.remove(user_data)

fastapi_fastkit/fastapi_project_template/fastapi-default/src/helper/exceptions.py-tpl

@@ -0,0 +1,94 @@
+# --------------------------------------------------------------------------
+# The module defines custom Backend Application Exception class, overrides basic Exception.
+# --------------------------------------------------------------------------
+from enum import Enum
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+from src.schemas import ResponseSchema
+
+
+class ErrorCode(Enum):
+    """
+    ErrorCode is designed to easily categorize errors into code in the log of the server application.
+
+    It is designed for custom code-based log filtering in third-party log monitoring systems
+    by matching with key HTTP status codes.
+    """
+    # HTTP
+    BAD_REQUEST = ("BAD_REQUEST", "HTTP-001", 400)
+    NOT_FOUND = ("NOT_FOUND", "HTTP-002", 404)
+    METHOD_NOT_ALLOWED = ("METHOD_NOT_ALLOWED", "HTTP-003", 405)
+    NOT_ACCESSABLE = ("NOT_ACCESSABLE", "HTTP-004", 406)
+    TIMEOUT = ("TIMEOUT", "HTTP-005", 408)
+    UNPROCESSABLE = ("UNPROCESSABLE", "HTTP-006", 422)
+    TOO_MANY_REQUEST = ("TOO_MANY_REQUEST", "HTTP-007", 429)
+
+    # DATA
+    CONFLICT = ("CONFLICT", "DATA-001", 409)
+
+    # AUTH
+    UNAUTHORIZED = ("UNAUTHORIZED", "AUTH-001", 401)
+    FORBIDDEN = ("FORBIDDEN", "AUTH-002", 403)
+
+    # SERVER
+    UNKNOWN_ERROR = ("UNKNOWN_ERROR", "SEVR-001", 500)
+    BAD_GATEWAY = ("BAD_GATEWAY", "SEVR-002", 502)
+    SERVICE_UNAVAILABLE = ("SERVICE_UNAVAILABLE", "SEVR-003", 503)
+    GATEWAY_TIMEOUT = ("GATEWAY_TIMEOUT", "SEVR-004", 504)
+
+    def __init__(self, error: str, code: str, status_code: int):
+        self.error = error
+        self.code = code
+        self.status_code = status_code
+
+
+class ExceptionSchema(BaseModel):
+    timestamp: str = Field(
+        ...,
+        description="Timestamp of the error occurred.",
+    )
+    status: int = Field(..., description="HTTP status code of the error")
+    code: str = Field(
+        ...,
+        description="Server identification code of the error.",
+    )
+    message: str = Field(
+        ...,
+        description="Message content of the error.",
+    )
+    path: str = Field(
+        ...,
+        description="Path where the error occurred.",
+    )
+
+    class ConfigDict:
+        json_schema_extra = {
+            "example": {
+                "default": {
+                    "timestamp": "2023-02-10T01:00:00.000Z",
+                    "status": 500,
+                    "code": "SEVR-000",
+                    "path": "/v1/<some/endpoint>",
+                    "message": "ERROR : Unknown error occurred in server logic.",
+                }
+            }
+        }
+
+
+class InternalException(Exception):
+    def __init__(self, message: str, error_code: ErrorCode):
+        self.timestamp = datetime.utcnow().isoformat() + "Z"
+        self.status = error_code.status_code
+        self.error_code = error_code.code
+        self.message = f"ERROR : {message}"
+
+    def to_response(self, path: str) -> ResponseSchema[str]:
+        return ResponseSchema(
+            timestamp=self.timestamp,
+            status=self.status,
+            code=self.error_code,
+            path=path,
+            message=self.message,
+        )

fastapi_fastkit/fastapi_project_template/fastapi-default/src/helper/global_data.py-tpl

@@ -0,0 +1,33 @@
+# --------------------------------------------------------------------------
+# The module initialize Mocking Data storage at FastAPI main coroutine's
+# memory space.
+# --------------------------------------------------------------------------
+import os
+import json
+
+# Global Mock Data storage (Stores : FastAPI app coroutine - In FastAPI thread memory)
+mock_user_data = []
+
+
+def initialize_mock_data() -> None:
+    base_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "../.."))
+    user_file_path = os.path.join(base_path, "src", "mocks", "mock_users.json")
+
+    with open(user_file_path, "r", encoding="utf-8") as f:
+        user_data = json.load(f)
+
+    # If the model has relations with other model,
+    # you can map it their respective columns like below:
+    item_data = [{'some': 'item', "user_id": "123e4567-e89b-12d3-a456-426614174000"}]
+    item_map = {}
+    for item in item_data:
+        user_id = item["user_id"]
+        if user_id not in item_map:
+            item_map[user_id] = []
+        item_map[user_id].append(item)
+
+    for user in user_data:
+        user_id = user["id"]
+        user["items"] = item_map.get(user_id, [])
+
+    mock_user_data.extend(user_data)

fastapi_fastkit/fastapi_project_template/fastapi-default/src/helper/logging.py-tpl

@@ -0,0 +1,25 @@
+# --------------------------------------------------------------------------
+# The module defines Backend Application's logger.
+# --------------------------------------------------------------------------
+import logging
+import logging.handlers
+
+from src.core.settings import AppSettings
+
+
+LOGGING_FORMAT = (
+    "[%(levelname)1.1s "
+    "%(asctime)s "
+    "P%(process)d "
+    "%(threadName)s "
+    "%(module)s:%(lineno)d] "
+    "%(message)s"
+)
+
+
+def init_logger(root_logger_name: str, app_settings: AppSettings) -> logging.Logger:
+    app_logger_level = (
+        logging.DEBUG if app_settings.LOGGING_DEBUG_LEVEL else logging.INFO
+    )
+
+    logging.basicConfig(level=app_logger_level, format=LOGGING_FORMAT)

fastapi_fastkit/fastapi_project_template/fastapi-default/src/helper/pagination.py-tpl

@@ -0,0 +1,71 @@
+# --------------------------------------------------------------------------
+# The module defines paginatable object schemas' helper methods.
+# --------------------------------------------------------------------------
+from typing import TypeVar, Generic, List, Optional
+from pydantic import BaseModel, Field, AnyHttpUrl
+from fastapi import Request
+
+T = TypeVar("T")
+
+
+class PaginatedResponse(BaseModel, Generic[T]):
+    count: int = Field(
+        ..., title="Count", description="Indicates the total number of imported items."
+    )
+    next: Optional[AnyHttpUrl] = Field(
+        None,
+        title="Next",
+        description="Indicates the URL of the next page to import the data.",
+    )
+    previous: Optional[AnyHttpUrl] = Field(
+        None,
+        title="Previous",
+        description="Indicates the URL of the previous page from which the data was imported.",
+    )
+    results: List[T] = Field(
+        ...,
+        title="Results",
+        description="Lists the information of the imported items.",
+    )
+
+
+class Paginator:
+    def __init__(self, data: List[T], page: int, per_page: int, request: Request):
+        self.data = data
+        self.page = page
+        self.page_size = per_page
+        self.limit = per_page
+        self.offset = (page - 1) * per_page
+        self.request = request
+        self.number_of_pages = self._get_number_of_pages(len(data))
+
+    def _get_next_page(self) -> Optional[str]:
+        if self.page >= self.number_of_pages:
+            return None
+        url = self.request.url.include_query_params(page=self.page + 1)
+        return str(url)
+
+    def _get_previous_page(self) -> Optional[str]:
+        if self.page == 1:
+            return None
+        url = self.request.url.include_query_params(page=self.page - 1)
+        return str(url)
+
+    def get_response(self) -> dict:
+        paginated_data = self.data[self.offset : self.offset + self.limit]
+        return {
+            "count": len(self.data),
+            "next": self._get_next_page(),
+            "previous": self._get_previous_page(),
+            "results": paginated_data,
+        }
+
+    def _get_number_of_pages(self, count: int) -> int:
+        rest = count % self.page_size
+        quotient = count // self.page_size
+        return quotient if not rest else quotient + 1
+
+
+def paginate(data: List[T], page: int, page_size: int, request: Request) -> dict:
+    paginator = Paginator(data, page, page_size, request)
+    return paginator.get_response()

fastapi_fastkit/fastapi_project_template/fastapi-default/src/mocks/mock_users.json-tpl

@@ -0,0 +1,17 @@
+[
+  {
+    "id": "123e4567-e89b-12d3-a456-426614174000",
+    "userId": "bnbong",
+    "email": "bbbong9@gmail.com",
+    "roles": ["NORMAL_USER"],
+    "profileImageUrl": null,
+    "bio": "hello, My name is JunHyeok Lee.",
+    "firstName": "JunHyeok",
+    "lastName": "Lee",
+    "gender": "M",
+    "country": "KOREA",
+    "isActive": true,
+    "createdDate": "2000-02-10T01:53:16.707426",
+    "password": "password123"
+  }
+]

fastapi_fastkit/fastapi_project_template/fastapi-default/src/router/__init__.py-tpl

@@ -0,0 +1,48 @@
+# --------------------------------------------------------------------------
+# The module connect routers to Backend Application.
+# --------------------------------------------------------------------------
+import os
+import json
+
+from uuid import UUID
+from datetime import datetime
+
+from fastapi import APIRouter, status, Request
+from fastapi.responses import JSONResponse, HTMLResponse
+from fastapi.templating import Jinja2Templates
+
+from src.helper.exceptions import InternalException
+
+from .user import router as user_router
+
+router = APIRouter(prefix="/v1")
+
+router.include_router(user_router, tags=["user"])
+
+templates = Jinja2Templates(os.path.join(os.path.dirname(__file__), "../templates"))
+
+
+@router.get("/", response_class=HTMLResponse, include_in_schema=False)
+async def root(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+
+@router.get(
+    "/ping",
+    summary="Server health check",
+    description="Checking FastAPI server's health.",
+    response_model=dict,
+    responses={
+        200: {
+            "description": "Ping Success",
+            "content": {"application/json": {"example": {"ping": "pong"}}},
+        },
+    },
+)
+async def ping():
+    return {"ping": "pong"}
+
+
+def load_json(file_path: str):
+    with open(file_path, "r", encoding="utf-8") as f:
+        return json.load(f)

fastapi_fastkit/fastapi_project_template/fastapi-default/src/router/user.py-tpl

@@ -0,0 +1,126 @@
+# --------------------------------------------------------------------------
+# The module defines User router.
+# --------------------------------------------------------------------------
+from . import *
+
+from src.helper.global_data import mock_user_data
+from src.crud.user import get_mock_user_data
+from src.schemas import ResponseSchema
+from src.schemas.user import UserSchema, UserCreate, UserUpdate
+
+
+router = APIRouter(
+    prefix="/user",
+)
+
+
+def generate_new_user_id():
+    if mock_user_data:
+        return max(_user["id"] for _user in mock_user_data) + 1
+    return 1
+
+
+@router.post(
+    "/",
+    summary="Create a new user.",
+    status_code=status.HTTP_201_CREATED,
+    response_model=UserSchema,
+)
+async def create_user_route(
+    data: UserCreate,
+    request: Request,
+):
+    try:
+        new_user = create_mock_user(data)
+        response = ResponseSchema(
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            status=201,
+            code="HTTP-201",
+            path=str(request.url),
+            message=UserSchema(**new_user),
+        )
+        return response
+    except InternalException as e:
+        return JSONResponse(
+            status_code=e.status,
+            content=e.to_response(path=str(request.url)).model_dump(),
+        )
+
+
+@router.get(
+    "/{id}",
+    summary="Get a user info",
+    description="Inquires information about a specific user.",
+    response_model=ResponseSchema[UserSchema],
+)
+async def get_user_route(id: UUID, request: Request):
+    try:
+        user = get_mock_user_data(id)
+        response = ResponseSchema(
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            status=200,
+            code="HTTP-200",
+            path=str(request.url),
+            message=UserSchema(**user),
+        )
+        return response
+    except InternalException as e:
+        return JSONResponse(
+            status_code=e.status,
+            content=e.to_response(path=str(request.url)).model_dump(),
+        )
+
+
+@router.patch(
+    "/{id}",
+    summary="Update a user.",
+    status_code=status.HTTP_200_OK,
+    response_model=UserSchema,
+)
+async def update_user_route(
+    id: UUID,
+    data: UserUpdate,
+):
+    try:
+        user = get_mock_user_data(id)
+        if user["username"] != request_user:
+            raise InternalException(
+                message="ERROR : You do not have permission to modify.", error_code=ErrorCode.UNAUTHORIZED
+            )
+        user.update(data.dict(exclude_unset=True))
+        user["modifiedAt"] = datetime.utcnow().isoformat() + "Z"
+        mock_user_data[mock_user_data.index(user)] = user
+        response = ResponseSchema(
+            timestamp=datetime.utcnow().isoformat() + "Z",
+            status=200,
+            code="HTTP-200",
+            path=str(request.url),
+            message=UserSchema(**user),
+        )
+        return response
+    except InternalException as e:
+        return JSONResponse(
+            status_code=e.status,
+            content=e.to_response(path=str(request.url)).model_dump(),
+        )
+
+
+@router.delete(
+    "/{id}",
+    summary="Delete a user.",
+    status_code=status.HTTP_204_NO_CONTENT,
+)
+async def delete_user_route(id: UUID):
+    try:
+        user = get_mock_user_data(id)
+        if user["username"] != request_user:
+            raise InternalException(
+                message="ERROR : You do not have permission to delete.", error_code=ErrorCode.UNAUTHORIZED
+            )
+        mock_user_data.remove(user)
+        return JSONResponse(status_code=status.HTTP_204_NO_CONTENT, content="")
+    except InternalException as e:
+        return JSONResponse(
+            status_code=e.status,
+            content=e.to_response(path=str(request.url)).model_dump(),
+        )

fastapi_fastkit/fastapi_project_template/fastapi-default/src/schemas/__init__.py-tpl

@@ -0,0 +1,48 @@
+# --------------------------------------------------------------------------
+# The module defines Base response schemas.
+# --------------------------------------------------------------------------
+from pydantic import BaseModel, Field
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class ResponseSchema(BaseModel, Generic[T]):
+    timestamp: str = Field(
+        ...,
+        description="The timestamp when the response was generated.",
+    )
+    status: int = Field(..., description="HTTP status code.")
+    code: str = Field(
+        ...,
+        description="Server identification code.",
+    )
+    path: str = Field(
+        ...,
+        description="Request path.",
+    )
+    message: T = Field(
+        ...,
+        description="Data details or error messages requested.",
+    )
+
+    class ConfigDict:
+        json_schema_extra = {
+            "example": {
+                "timestamp": "2023-02-10T01:00:00.000Z",
+                "status": 200,
+                "code": "HTTP-200",
+                "path": "/v1/<some/endpoint>",
+                "message": {
+                    "id": "123e4567-e89b-12d3-a456-426614174000",
+                    "email": "example@example.com",
+                    "password": "secret",
+                    "nickname": "example_nick",
+                    "create_at": "2023-02-10T01:00:00.000Z",
+                    "bio": "example bio",
+                    "profile_img": "https://example.com/profile.jpg",
+                    "first_name": "John",
+                    "last_name": "Doe",
+                },
+            }
+        }

fastapi_fastkit/fastapi_project_template/fastapi-default/src/schemas/user.py-tpl

@@ -0,0 +1,81 @@
+# --------------------------------------------------------------------------
+# The module defines User schemas.
+# --------------------------------------------------------------------------
+from datetime import datetime, date
+from uuid import UUID
+from enum import Enum
+
+from pydantic import BaseModel, Field, EmailStr, SecretStr, field_serializer
+from typing import Optional, List
+
+
+class UserBase(BaseModel):
+    email: EmailStr = Field(
+        ..., title="User's Email", description="The email address of the user."
+    )
+    bio: str = Field(None, title="User's bio", description="Personal introduction of the user.")
+    firstName: str = Field(
+        ..., title="User's first name", description="The real name of the user."
+    )
+    lastName: str = Field(
+        ..., title="User's last name", description="The last name of the user."
+    )
+    gender: str = Field(..., title="User's gender", description="The gender of the user.")
+    country: str = Field(..., title="User's country", description="Country of the user.")
+    isActive: bool = Field(
+        ..., title="User's active status", description="The active state of the user."
+    )
+    createdDate: datetime = Field(
+        ...,
+        title="User's account created date",
+        description="Date of creation of the user account.",
+    )
+    password: Optional[SecretStr] = Field(
+        None, title="User's password", description="Password of the user account."
+    )
+
+    # items: Optional[List] = List[ItemSchema]
+
+    @field_serializer("password", when_used="json")
+    def dump_secret(self, v):
+        return v.get_secret_value()
+
+
+class UserSchema(UserBase):
+    id: UUID = Field(
+        ..., title="User's ID (pk)", description="The unique database identifier for the user."
+    )
+    userId: str = Field(..., title="User's ID", description="ID of the user account.")
+    roles: List[str] = Field(
+        ..., title="User's roles", description="List of roles for the user."
+    )
+    profileImageUrl: Optional[str] = Field(
+        None,
+        title="User's profile image URL",
+        description="The URL of the user's profile image.",
+    )
+
+    class ConfigDict:
+        from_attributes = True
+
+
+class UserCreate(UserBase):
+    firstName: str = Field(
+        ..., title="User's first name", description="The real name of the user."
+    )
+    lastName: str = Field(
+        ..., title="User's last name", description="The last name of the user."
+    )
+    email: EmailStr = Field(
+        ..., title="User's Email", description="The email address of the user."
+    )
+    password: str = Field(
+        ..., title="User's password", description="Password of the user account."
+    )
+
+
+class UserUpdate(BaseModel):
+    bio: str = Field(None, title="User's bio", description="Personal introduction of the user.")
+    profileImg: str = Field(
+        None, title="User's profile image", description="The URL of the user's profile image."
+    )