spakky-fastapi 1.7.0__tar.gz → 2.0.1__tar.gz

{spakky_fastapi-1.7.0 → spakky_fastapi-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spakky-fastapi
-Version: 1.7.0
+Version: 2.0.1
 Summary: Highly abstracted Framework core to use DDD & DI/IoC & AOP & Etc...
 Author: Spakky
 Author-email: sejong418@icloud.com
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: fastapi (>=0.115.5,<0.116.0)
 Requires-Dist: orjson (>=3.10.11,<4.0.0)
-Requires-Dist: spakky-core (>=1.8,<2.0)
+Requires-Dist: spakky-core (>=2.10)
 Requires-Dist: websockets (>=14.1,<15.0)
 Description-Content-Type: text/markdown
 

{spakky_fastapi-1.7.0 → spakky_fastapi-2.0.1}/pyproject.toml

@@ -1,10 +1,13 @@
 [tool.poetry]
 name = "spakky-fastapi"
-version = "1.7.0"
+version = "2.0.1"
 description = "Highly abstracted Framework core to use DDD & DI/IoC & AOP & Etc..."
 authors = ["Spakky <sejong418@icloud.com>"]
 readme = "README.md"
 
+[tool.poetry.plugins."spakky.plugins"]
+fastapi = "spakky_fastapi.main:initialize"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
@@ -12,67 +15,31 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry.dependencies]
 python = ">=3.10"
 fastapi = "^0.115.5"
-spakky-core = "^1.8"
+spakky-core = ">=2.10"
 websockets = "^14.1"
 orjson = "^3.10.11"
 
 [tool.poetry.group.dev.dependencies]
-pylint = "^3.0.2"
-black = "^24.4.2"
-isort = "^5.12.0"
 pytest = "^7.4.3"
 pytest-cov = "^4.1.0"
 pytest-asyncio = "^0.21.1"
 pytest-xdist = "^3.6.1"
 toml = "^0.10.2"
 httpx = "^0.27.2"
+ruff = "^0.9.7"
+pre-commit = "^4.1.0"
 
 [tool.poetry.group.ci.dependencies]
-pylint = "^3.0.2"
 pytest = "^7.4.3"
 pytest-cov = "^4.1.0"
 pytest-asyncio = "^0.21.1"
 pytest-xdist = "^3.6.1"
 httpx = "^0.27.2"
+ruff = "^0.9.7"
 
-[tool.black]
-line-length = 90
-target-version = ["py310"]
-include = '\.pyi?$'
-
-[tool.isort]
-py_version = 310
-src_paths = ["spakky_fastapi", "tests"]
-skip = [".venv", ".gitignore", ".dockerignore"]
-extend_skip = [".md", ".json", ".txt"]
-profile = "black"
-combine_as_imports = true
-remove_redundant_aliases = true
-length_sort_sections = ["future", "stdlib"]
-
-[tool.pylint]
-ignore-paths = [".venv", "tests"]
-
-[tool.pylint.'MESSAGES CONTROL']
-max-line-length = 90
-disable = """
-    no-member,
-    arguments-differ,
-    invalid-field-call,
-    too-many-arguments,
-    missing-module-docstring,
-    missing-class-docstring,
-    missing-function-docstring,
-    too-many-positional-arguments,
-    too-many-instance-attributes,
-    too-few-public-methods,
-    unnecessary-ellipsis,
-    redefined-builtin,
-    too-many-locals,
-    multiple-statements,
-    consider-using-f-string,
-    duplicate-code,
-"""
+[tool.ruff]
+builtins = ["_"]
+cache-dir = "~/.cache/ruff"
 
 [tool.pytest.ini_options]
 pythonpath = "spakky"

spakky_fastapi-2.0.1/spakky_fastapi/error.py

@@ -0,0 +1,54 @@
+import traceback
+from abc import ABC
+from typing import ClassVar
+
+from fastapi import status
+from fastapi.responses import JSONResponse, ORJSONResponse
+from spakky.core.error import AbstractSpakkyCoreError
+
+
+class AbstractSpakkyFastAPIError(AbstractSpakkyCoreError, ABC):
+    status_code: ClassVar[int]
+
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+    def to_response(self, show_traceback: bool) -> JSONResponse:
+        return ORJSONResponse(
+            content={
+                "message": self.message,
+                "args": [str(x) for x in self.args],
+                "traceback": traceback.format_exc() if show_traceback else None,
+            },
+            status_code=self.status_code,
+        )
+
+
+class BadRequest(AbstractSpakkyFastAPIError):
+    message: ClassVar[str] = "Bad Request"
+    status_code: ClassVar[int] = status.HTTP_400_BAD_REQUEST
+
+
+class Unauthorized(AbstractSpakkyFastAPIError):
+    message: ClassVar[str] = "Unauthorized"
+    status_code: ClassVar[int] = status.HTTP_401_UNAUTHORIZED
+
+
+class Forbidden(AbstractSpakkyFastAPIError):
+    message: ClassVar[str] = "Forbidden"
+    status_code: ClassVar[int] = status.HTTP_403_FORBIDDEN
+
+
+class NotFound(AbstractSpakkyFastAPIError):
+    message: ClassVar[str] = "Not Found"
+    status_code: ClassVar[int] = status.HTTP_404_NOT_FOUND
+
+
+class Conflict(AbstractSpakkyFastAPIError):
+    message: ClassVar[str] = "Conflict"
+    status_code: ClassVar[int] = status.HTTP_409_CONFLICT
+
+
+class InternalServerError(AbstractSpakkyFastAPIError):
+    message: ClassVar[str] = "Internal Server Error"
+    status_code: ClassVar[int] = status.HTTP_500_INTERNAL_SERVER_ERROR

spakky_fastapi-2.0.1/spakky_fastapi/main.py

@@ -0,0 +1,11 @@
+from spakky.application.application import SpakkyApplication
+
+from spakky_fastapi.post_processors.add_builtin_middlewares import (
+    AddBuiltInMiddlewaresPostProcessor,
+)
+from spakky_fastapi.post_processors.register_routes import RegisterRoutesPostProcessor
+
+
+def initialize(app: SpakkyApplication) -> None:
+    app.add(AddBuiltInMiddlewaresPostProcessor)
+    app.add(RegisterRoutesPostProcessor)

{spakky_fastapi-1.7.0 → spakky_fastapi-2.0.1}/spakky_fastapi/middlewares/error_handling.py

@@ -1,12 +1,11 @@
-import traceback
-from typing import Callable, Awaitable, TypeAlias
+from typing import Awaitable, Callable, TypeAlias
 
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware, DispatchFunction
 from starlette.responses import Response
 from starlette.types import ASGIApp
 
-from spakky_fastapi.error import InternalServerError, SpakkyFastAPIError
+from spakky_fastapi.error import AbstractSpakkyFastAPIError, InternalServerError
 
 Next: TypeAlias = Callable[[Request], Awaitable[Response]]
 
@@ -26,12 +25,7 @@ class ErrorHandlingMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next: Next) -> Response:
         try:
             return await call_next(request)
-        except SpakkyFastAPIError as e:
-            return e.to_response()
-        except Exception as e:  # pylint: disable=broad-exception-caught
-            if self.__debug:
-                traceback.print_exc()  # pragma: no cover
-            return InternalServerError(
-                error=e,
-                stacktrace=traceback.format_exc() if self.__debug else None,
-            ).to_response()
+        except AbstractSpakkyFastAPIError as e:
+            return e.to_response(self.__debug)
+        except Exception:
+            return InternalServerError().to_response(self.__debug)

spakky_fastapi-2.0.1/spakky_fastapi/middlewares/manage_context.py

@@ -0,0 +1,26 @@
+from typing import Awaitable, Callable, TypeAlias
+
+from fastapi import Request
+from spakky.pod.interfaces.application_context import IApplicationContext
+from starlette.middleware.base import BaseHTTPMiddleware, DispatchFunction
+from starlette.responses import Response
+from starlette.types import ASGIApp
+
+Next: TypeAlias = Callable[[Request], Awaitable[Response]]
+
+
+class ManageContextMiddleware(BaseHTTPMiddleware):
+    __application_context: IApplicationContext
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        application_context: IApplicationContext,
+        dispatch: DispatchFunction | None = None,
+    ) -> None:
+        super().__init__(app, dispatch)
+        self.__application_context = application_context
+
+    async def dispatch(self, request: Request, call_next: Next) -> Response:
+        self.__application_context.clear_context()
+        return await call_next(request)

spakky_fastapi-2.0.1/spakky_fastapi/post_processors/add_builtin_middlewares.py

@@ -0,0 +1,34 @@
+from fastapi import FastAPI
+from spakky.pod.annotations.order import Order
+from spakky.pod.annotations.pod import Pod
+from spakky.pod.interfaces.application_context import IApplicationContext
+from spakky.pod.interfaces.aware.application_context_aware import (
+    IApplicationContextAware,
+)
+from spakky.pod.interfaces.post_processor import IPostProcessor
+
+from spakky_fastapi.middlewares.error_handling import ErrorHandlingMiddleware
+from spakky_fastapi.middlewares.manage_context import ManageContextMiddleware
+
+
+@Order(0)
+@Pod()
+class AddBuiltInMiddlewaresPostProcessor(IPostProcessor, IApplicationContextAware):
+    __application_context: IApplicationContext
+
+    def set_application_context(self, application_context: IApplicationContext) -> None:
+        self.__application_context = application_context
+
+    def post_process(self, pod: object) -> object:
+        if not isinstance(pod, FastAPI):
+            return pod
+
+        pod.add_middleware(
+            ErrorHandlingMiddleware,
+            debug=pod.debug,
+        )
+        pod.add_middleware(
+            ManageContextMiddleware,
+            application_context=self.__application_context,
+        )
+        return pod

spakky_fastapi-2.0.1/spakky_fastapi/post_processors/register_routes.py

@@ -0,0 +1,104 @@
+from dataclasses import asdict
+from functools import wraps
+from inspect import getmembers, signature
+from logging import Logger
+from typing import Any
+
+from fastapi import APIRouter, FastAPI
+from fastapi.exceptions import FastAPIError
+from fastapi.utils import create_model_field  # type: ignore
+from spakky.pod.annotations.order import Order
+from spakky.pod.annotations.pod import Pod
+from spakky.pod.interfaces.aware.container_aware import IContainerAware
+from spakky.pod.interfaces.aware.logger_aware import ILoggerAware
+from spakky.pod.interfaces.container import IContainer
+from spakky.pod.interfaces.post_processor import IPostProcessor
+
+from spakky_fastapi.routes.route import Route
+from spakky_fastapi.routes.websocket import WebSocketRoute
+from spakky_fastapi.stereotypes.api_controller import ApiController
+
+
+@Order(0)
+@Pod()
+class RegisterRoutesPostProcessor(IPostProcessor, ILoggerAware, IContainerAware):
+    __logger: Logger
+    __container: IContainer
+
+    def set_logger(self, logger: Logger) -> None:
+        self.__logger = logger
+
+    def set_container(self, container: IContainer) -> None:
+        self.__container = container
+
+    def post_process(self, pod: object) -> object:
+        if not ApiController.exists(pod):
+            return pod
+
+        fast_api = self.__container.get(FastAPI)
+        controller = ApiController.get(pod)
+        router: APIRouter = APIRouter(prefix=controller.prefix, tags=controller.tags)
+        for name, method in getmembers(pod, callable):
+            route: Route | None = Route.get_or_none(method)
+            websocket_route: WebSocketRoute | None = WebSocketRoute.get_or_none(method)
+            if route is None and websocket_route is None:
+                continue
+
+            if route is not None:
+                # pylint: disable=line-too-long
+                self.__logger.debug(
+                    f"[{type(self).__name__}] {route.methods!r} {controller.prefix}{route.path} -> {method.__qualname__}"
+                )
+                if route.name is None:
+                    route.name = " ".join([x.capitalize() for x in name.split("_")])
+                if route.description is None:
+                    route.description = method.__doc__
+                if route.response_model is None:
+                    return_annotation: type | None = signature(method).return_annotation
+                    if return_annotation is not None:
+                        try:
+                            create_model_field("", return_annotation)
+                            route.response_model = return_annotation
+                        except FastAPIError:
+                            pass
+
+                @wraps(method)
+                async def endpoint(
+                    *args: Any,
+                    method_name: str = name,
+                    controller_type: type[object] = controller.type_,
+                    context: IContainer = self.__container,
+                    **kwargs: Any,
+                ) -> Any:
+                    controller_instance = context.get(controller_type)
+                    method_to_call = getattr(controller_instance, method_name)
+                    return await method_to_call(*args, **kwargs)
+
+                router.add_api_route(endpoint=endpoint, **asdict(route))
+            if websocket_route is not None:
+                # pylint: disable=line-too-long
+                self.__logger.debug(
+                    f"[{type(self).__name__}] [WebSocket] {controller.prefix}{websocket_route.path} -> {method.__qualname__}"
+                )
+                if websocket_route.name is None:
+                    websocket_route.name = " ".join(
+                        [x.capitalize() for x in name.split("_")]
+                    )
+
+                @wraps(method)
+                async def websocket_endpoint(
+                    *args: Any,
+                    method_name: str = name,
+                    controller_type: type[object] = controller.type_,
+                    context: IContainer = self.__container,
+                    **kwargs: Any,
+                ) -> Any:
+                    controller_instance = context.get(controller_type)
+                    method_to_call = getattr(controller_instance, method_name)
+                    return await method_to_call(*args, **kwargs)
+
+                router.add_api_websocket_route(
+                    endpoint=websocket_endpoint, **asdict(websocket_route)
+                )
+        fast_api.include_router(router)
+        return pod

spakky_fastapi-2.0.1/spakky_fastapi/routes/__init__.py

@@ -0,0 +1,21 @@
+from .delete import delete
+from .get import get
+from .head import head
+from .options import options
+from .patch import patch
+from .post import post
+from .put import put
+from .route import route
+from .websocket import websocket
+
+__all__ = [
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put",
+    "route",
+    "websocket",
+]

spakky_fastapi-2.0.1/spakky_fastapi/routes/delete.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, Sequence
+
+from fastapi import Response, params
+from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
+from spakky.core.types import FuncT
+from starlette.routing import Route as StarletteRoute
+
+from spakky_fastapi.routes.route import DictIntStrAny, HTTPMethod, SetIntStr, route
+
+
+def delete(
+    path: str,
+    response_model: type[Any] | None = None,
+    status_code: int | None = None,
+    tags: list[str] | None = None,
+    dependencies: Sequence[params.Depends] | None = None,
+    summary: str | None = None,
+    description: str | None = None,
+    response_description: str = "Successful Response",
+    responses: dict[int | str, dict[str, Any]] | None = None,
+    deprecated: bool | None = None,
+    operation_id: str | None = None,
+    response_model_include: SetIntStr | DictIntStrAny | None = None,
+    response_model_exclude: SetIntStr | DictIntStrAny | 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,
+    route_class_override: type[APIRoute] | None = None,
+    callbacks: list[StarletteRoute] | None = None,
+    openapi_extra: dict[str, Any] | None = None,
+) -> Callable[[FuncT], FuncT]:
+    return route(
+        path=path,
+        methods=[HTTPMethod.DELETE],
+        response_model=response_model,
+        status_code=status_code,
+        tags=tags,
+        dependencies=dependencies,
+        summary=summary,
+        description=description,
+        response_description=response_description,
+        responses=responses,
+        deprecated=deprecated,
+        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,
+        route_class_override=route_class_override,
+        callbacks=callbacks,
+        openapi_extra=openapi_extra,
+    )

spakky_fastapi-2.0.1/spakky_fastapi/routes/get.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, Sequence
+
+from fastapi import Response, params
+from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
+from spakky.core.types import FuncT
+from starlette.routing import Route as StarletteRoute
+
+from spakky_fastapi.routes.route import DictIntStrAny, HTTPMethod, SetIntStr, route
+
+
+def get(
+    path: str,
+    response_model: type[Any] | None = None,
+    status_code: int | None = None,
+    tags: list[str] | None = None,
+    dependencies: Sequence[params.Depends] | None = None,
+    summary: str | None = None,
+    description: str | None = None,
+    response_description: str = "Successful Response",
+    responses: dict[int | str, dict[str, Any]] | None = None,
+    deprecated: bool | None = None,
+    operation_id: str | None = None,
+    response_model_include: SetIntStr | DictIntStrAny | None = None,
+    response_model_exclude: SetIntStr | DictIntStrAny | 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,
+    route_class_override: type[APIRoute] | None = None,
+    callbacks: list[StarletteRoute] | None = None,
+    openapi_extra: dict[str, Any] | None = None,
+) -> Callable[[FuncT], FuncT]:
+    return route(
+        path=path,
+        methods=[HTTPMethod.GET],
+        response_model=response_model,
+        status_code=status_code,
+        tags=tags,
+        dependencies=dependencies,
+        summary=summary,
+        description=description,
+        response_description=response_description,
+        responses=responses,
+        deprecated=deprecated,
+        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,
+        route_class_override=route_class_override,
+        callbacks=callbacks,
+        openapi_extra=openapi_extra,
+    )

spakky_fastapi-2.0.1/spakky_fastapi/routes/head.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, Sequence
+
+from fastapi import Response, params
+from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
+from spakky.core.types import FuncT
+from starlette.routing import Route as StarletteRoute
+
+from spakky_fastapi.routes.route import DictIntStrAny, HTTPMethod, SetIntStr, route
+
+
+def head(
+    path: str,
+    response_model: type[Any] | None = None,
+    status_code: int | None = None,
+    tags: list[str] | None = None,
+    dependencies: Sequence[params.Depends] | None = None,
+    summary: str | None = None,
+    description: str | None = None,
+    response_description: str = "Successful Response",
+    responses: dict[int | str, dict[str, Any]] | None = None,
+    deprecated: bool | None = None,
+    operation_id: str | None = None,
+    response_model_include: SetIntStr | DictIntStrAny | None = None,
+    response_model_exclude: SetIntStr | DictIntStrAny | 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,
+    route_class_override: type[APIRoute] | None = None,
+    callbacks: list[StarletteRoute] | None = None,
+    openapi_extra: dict[str, Any] | None = None,
+) -> Callable[[FuncT], FuncT]:
+    return route(
+        path=path,
+        methods=[HTTPMethod.HEAD],
+        response_model=response_model,
+        status_code=status_code,
+        tags=tags,
+        dependencies=dependencies,
+        summary=summary,
+        description=description,
+        response_description=response_description,
+        responses=responses,
+        deprecated=deprecated,
+        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,
+        route_class_override=route_class_override,
+        callbacks=callbacks,
+        openapi_extra=openapi_extra,
+    )

spakky_fastapi-2.0.1/spakky_fastapi/routes/options.py

@@ -0,0 +1,62 @@
+from typing import Any, Callable, Sequence
+
+from fastapi import Response, params
+from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
+from spakky.core.types import FuncT
+from starlette.routing import Route as StarletteRoute
+
+from spakky_fastapi.routes.route import DictIntStrAny, HTTPMethod, SetIntStr, route
+
+
+def options(
+    path: str,
+    response_model: type[Any] | None = None,
+    status_code: int | None = None,
+    tags: list[str] | None = None,
+    dependencies: Sequence[params.Depends] | None = None,
+    summary: str | None = None,
+    description: str | None = None,
+    response_description: str = "Successful Response",
+    responses: dict[int | str, dict[str, Any]] | None = None,
+    deprecated: bool | None = None,
+    operation_id: str | None = None,
+    response_model_include: SetIntStr | DictIntStrAny | None = None,
+    response_model_exclude: SetIntStr | DictIntStrAny | 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,
+    route_class_override: type[APIRoute] | None = None,
+    callbacks: list[StarletteRoute] | None = None,
+    openapi_extra: dict[str, Any] | None = None,
+) -> Callable[[FuncT], FuncT]:
+    return route(
+        path=path,
+        methods=[HTTPMethod.OPTIONS],
+        response_model=response_model,
+        status_code=status_code,
+        tags=tags,
+        dependencies=dependencies,
+        summary=summary,
+        description=description,
+        response_description=response_description,
+        responses=responses,
+        deprecated=deprecated,
+        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,
+        route_class_override=route_class_override,
+        callbacks=callbacks,
+        openapi_extra=openapi_extra,
+    )