spakky-fastapi 0.7.19__py3-none-any.whl → 0.10.0__py3-none-any.whl

spakky_fastapi/{jwt_auth.py → aspects/jwt_auth.py}

@@ -1,20 +1,21 @@
 from typing import Any, TypeVar, Callable, Annotated, Awaitable, TypeAlias, Concatenate
+from inspect import iscoroutinefunction
 from logging import Logger
 from dataclasses import InitVar, field, dataclass
 
 from fastapi import Depends
 from fastapi.security import OAuth2PasswordBearer
 from spakky.aop.advice import Around
-from spakky.aop.advisor import IAsyncAdvisor
-from spakky.aop.aspect import AsyncAspect
+from spakky.aop.advisor import IAdvisor, IAsyncAdvisor
+from spakky.aop.aspect import Aspect, AsyncAspect
 from spakky.aop.error import SpakkyAOPError
 from spakky.aop.order import Order
-from spakky.bean.autowired import autowired
 from spakky.core.annotation import FunctionAnnotation
-from spakky.core.types import AsyncFunc, P
+from spakky.core.types import AsyncFunc, Func, P
 from spakky.cryptography.error import InvalidJWTFormatError, JWTDecodingError
 from spakky.cryptography.jwt import JWT
 from spakky.cryptography.key import Key
+
 from spakky_fastapi.error import Unauthorized
 
 R_co = TypeVar("R_co", covariant=True)
@@ -24,7 +25,10 @@ class AuthenticationFailedError(SpakkyAOPError):
     message = "사용자 인증에 실패했습니다."
 
 
-IAuthenticatedFunction: TypeAlias = Callable[Concatenate[Any, JWT, P], Awaitable[R_co]]
+IAuthenticatedFunction: TypeAlias = (
+    Callable[Concatenate[Any, JWT, P], R_co]
+    | Callable[Concatenate[Any, JWT, P], Awaitable[R_co]]
+)
 
 
 @dataclass
@@ -46,19 +50,47 @@ class JWTAuth(FunctionAnnotation):
         return super().__call__(obj)
 
 
+@Order(1)
+@Aspect()
+class JWTAuthAdvisor(IAdvisor):
+    __logger: Logger
+    __key: Key
+
+    def __init__(self, logger: Logger, key: Key) -> None:
+        super().__init__()
+        self.__logger = logger
+        self.__key = key
+
+    @Around(lambda x: JWTAuth.contains(x) and not iscoroutinefunction(x))
+    def around(self, joinpoint: Func, *args: Any, **kwargs: Any) -> Any:
+        annotation: JWTAuth = JWTAuth.single(joinpoint)
+        for keyword in annotation.token_keywords:
+            token: str = kwargs[keyword]
+            try:
+                jwt: JWT = JWT(token=token)
+            except (InvalidJWTFormatError, JWTDecodingError) as e:
+                raise Unauthorized(AuthenticationFailedError()) from e
+            if jwt.is_expired:
+                raise Unauthorized(AuthenticationFailedError())
+            if jwt.verify(self.__key) is False:
+                raise Unauthorized(AuthenticationFailedError())
+            self.__logger.info(f"[{type(self).__name__}] {jwt.payload!r}")
+            kwargs[keyword] = jwt
+        return joinpoint(*args, **kwargs)
+
+
 @Order(1)
 @AsyncAspect()
 class AsyncJWTAuthAdvisor(IAsyncAdvisor):
     __logger: Logger
     __key: Key
 
-    @autowired
     def __init__(self, logger: Logger, key: Key) -> None:
         super().__init__()
         self.__logger = logger
         self.__key = key
 
-    @Around(JWTAuth.contains)
+    @Around(lambda x: JWTAuth.contains(x) and iscoroutinefunction(x))
     async def around_async(self, joinpoint: AsyncFunc, *args: Any, **kwargs: Any) -> Any:
         annotation: JWTAuth = JWTAuth.single(joinpoint)
         for keyword in annotation.token_keywords:

spakky_fastapi/middlewares/error_handling.py

@@ -3,9 +3,11 @@ from typing import Callable, Awaitable, TypeAlias
 from fastapi import Request
 from fastapi.responses import ORJSONResponse
 from pydantic import BaseModel
-from spakky_fastapi.error import InternalServerError, SpakkyFastAPIError
-from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.middleware.base import BaseHTTPMiddleware, DispatchFunction
 from starlette.responses import Response
+from starlette.types import ASGIApp
+
+from spakky_fastapi.error import InternalServerError, SpakkyFastAPIError
 
 Next: TypeAlias = Callable[[Request], Awaitable[Response]]
 
@@ -13,9 +15,21 @@ Next: TypeAlias = Callable[[Request], Awaitable[Response]]
 class ErrorResponse(BaseModel):
     message: str
     args: list[str]
+    traceback: str = ""
 
 
 class ErrorHandlingMiddleware(BaseHTTPMiddleware):
+    __debug: bool
+
+    def __init__(
+        self,
+        app: ASGIApp,
+        dispatch: DispatchFunction | None = None,
+        debug: bool = False,
+    ) -> None:
+        super().__init__(app, dispatch)
+        self.__debug = debug
+
     async def dispatch(self, request: Request, call_next: Next) -> Response:
         try:
             return await call_next(request)
@@ -34,6 +48,7 @@ class ErrorHandlingMiddleware(BaseHTTPMiddleware):
                 content=ErrorResponse(
                     message=error.message,
                     args=[str(x) for x in error.args],
+                    traceback=error.traceback if self.__debug else "",
                 ).model_dump(),
                 status_code=error.status_code,
             )

spakky_fastapi/plugins/fast_api.py

@@ -0,0 +1,24 @@
+from logging import Logger
+
+from fastapi import FastAPI
+from spakky.application.interfaces.pluggable import IPluggable
+from spakky.application.interfaces.registry import IRegistry
+
+from spakky_fastapi.post_processor import FastAPIBeanPostProcessor
+
+
+class FastAPIPlugin(IPluggable):
+    app: FastAPI
+    logger: Logger
+
+    def __init__(self, app: FastAPI, logger: Logger) -> None:
+        self.app = app
+        self.logger = logger
+
+    def register(self, registry: IRegistry) -> None:
+        registry.register_bean_post_processor(
+            FastAPIBeanPostProcessor(
+                self.app,
+                self.logger,
+            )
+        )

spakky_fastapi/plugins/jwt_auth.py

@@ -0,0 +1,10 @@
+from spakky.application.interfaces.pluggable import IPluggable
+from spakky.application.interfaces.registry import IRegistry
+
+from spakky_fastapi.aspects.jwt_auth import AsyncJWTAuthAdvisor, JWTAuthAdvisor
+
+
+class JWTAuthPlugin(IPluggable):
+    def register(self, registry: IRegistry) -> None:
+        registry.register_bean(JWTAuthAdvisor)
+        registry.register_bean(AsyncJWTAuthAdvisor)

spakky_fastapi/post_processor.py

@@ -6,10 +6,14 @@ from dataclasses import asdict
 from fastapi import APIRouter, FastAPI
 from fastapi.exceptions import FastAPIError
 from fastapi.utils import create_response_field  # type: ignore
-from spakky.bean.interfaces.bean_container import IBeanContainer
-from spakky.bean.interfaces.bean_processor import IBeanPostProcessor
-from spakky_fastapi.routing import Route, WebSocketRoute
-from spakky_fastapi.stereotypes.api_controller import ApiController
+from spakky.application.interfaces.bean_container import IBeanContainer
+from spakky.application.interfaces.bean_processor import IBeanPostProcessor
+
+from spakky_fastapi.stereotypes.api_controller import (
+    ApiController,
+    Route,
+    WebSocketRoute,
+)
 
 
 class FastAPIBeanPostProcessor(IBeanPostProcessor):
@@ -32,6 +36,7 @@ class FastAPIBeanPostProcessor(IBeanPostProcessor):
             if route is None and websocket_route is None:
                 continue
             if route is not None:
+                # pylint: disable=line-too-long
                 self.__logger.info(
                     f"[{type(self).__name__}] {route.methods!r} {controller.prefix}{route.path} -> {method.__qualname__}"
                 )
@@ -50,6 +55,7 @@ class FastAPIBeanPostProcessor(IBeanPostProcessor):
                             route.response_model = return_annotation
                 router.add_api_route(endpoint=method, **asdict(route))
             if websocket_route is not None:
+                # pylint: disable=line-too-long
                 self.__logger.info(
                     f"[{type(self).__name__}] [WebSocket] {controller.prefix}{websocket_route.path} -> {method.__qualname__}"
                 )

spakky_fastapi/stereotypes/api_controller.py

@@ -1,7 +1,506 @@
 from enum import Enum
+from typing import Any, Callable, Sequence, TypeAlias
 from dataclasses import dataclass
 
+from fastapi import Response, params
+from fastapi.responses import JSONResponse
+from fastapi.routing import APIRoute
+from spakky.core.annotation import FunctionAnnotation
+from spakky.core.types import FuncT
 from spakky.stereotype.controller import Controller
+from starlette.routing import Route as StarletteRoute
+
+SetIntStr: TypeAlias = set[int | str]
+DictIntStrAny: TypeAlias = dict[int | str, Any]
+
+
+class HTTPMethod(str, Enum):
+    GET = "GET"
+    POST = "POST"
+    PUT = "PUT"
+    PATCH = "PATCH"
+    DELETE = "DELETE"
+    HEAD = "HEAD"
+    OPTIONS = "OPTIONS"
+    TRACE = "TRACE"
+
+    def __repr__(self) -> str:
+        return self.value
+
+
+@dataclass
+class Route(FunctionAnnotation):
+    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
+    methods: set[HTTPMethod] | list[HTTPMethod] | 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
+
+
+@dataclass
+class WebSocketRoute(FunctionAnnotation):
+    path: str
+    name: str | None = None
+    dependencies: Sequence[params.Depends] | None = None
+
+
+def route(
+    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,
+    methods: set[HTTPMethod] | list[HTTPMethod] | 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]:
+    def wrapper(method: FuncT) -> FuncT:
+        return Route(
+            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,
+            route_class_override=route_class_override,
+            callbacks=callbacks,
+            openapi_extra=openapi_extra,
+        )(method)
+
+    return wrapper
+
+
+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,
+    )
+
+
+def post(
+    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.POST],
+        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,
+    )
+
+
+def put(
+    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.PUT],
+        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,
+    )
+
+
+def patch(
+    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.PATCH],
+        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,
+    )
+
+
+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,
+    )
+
+
+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,
+    )
+
+
+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,
+    )
+
+
+def websocket(
+    path: str,
+    name: str | None = None,
+    dependencies: Sequence[params.Depends] | None = None,
+) -> Callable[[FuncT], FuncT]:
+    return WebSocketRoute(
+        path=path,
+        name=name,
+        dependencies=dependencies,
+    )
 
 
 @dataclass

{spakky_fastapi-0.7.19.dist-info → spakky_fastapi-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spakky-fastapi
-Version: 0.7.19
+Version: 0.10.0
 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.109.2,<0.110.0)
 Requires-Dist: orjson (>=3.9.15,<4.0.0)
-Requires-Dist: spakky-core (>=0.7.14)
+Requires-Dist: spakky-core (>=0.12,<0.13)
 Requires-Dist: websockets (>=12.0,<13.0)
 Description-Content-Type: text/markdown
 

spakky_fastapi-0.10.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+spakky_fastapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spakky_fastapi/aspects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spakky_fastapi/aspects/jwt_auth.py,sha256=1OSpCQDWiBzseH5IPfgutjQCNKabnNFMCRNQRBoENE8,4007
+spakky_fastapi/error.py,sha256=SWyNZk1kxbTCiy-tLxB8saLpX5rBxwvy7q7JRCtNQV0,1124
+spakky_fastapi/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spakky_fastapi/middlewares/error_handling.py,sha256=SeqEZeGYdRvQTAcbVlcP6bGHXGi5RL9S6ZnsG6PDgTE,1712
+spakky_fastapi/plugins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spakky_fastapi/plugins/fast_api.py,sha256=lSXABplfyl3jASaT3NV4Z1hC-EtHqilXqyN98Y756v4,652
+spakky_fastapi/plugins/jwt_auth.py,sha256=UN05gI9cYHrQERIYYigLqsFMxOdgvceusg6AZO1KN_Y,392
+spakky_fastapi/post_processor.py,sha256=gTUubo-vOy_uB6rytT8vuNuRgQV2fOdsDqPx93cf8oI,2983
+spakky_fastapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spakky_fastapi/stereotypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spakky_fastapi/stereotypes/api_controller.py,sha256=NM0gyTQfuHnENtvyfm5T9Y427gQdxdUcVYDzAXryF2M,19320
+spakky_fastapi-0.10.0.dist-info/METADATA,sha256=ngtKUdnSZj5wpDSAcBvvTVdQ4F9ekqOzjvJifNiBRqM,1706
+spakky_fastapi-0.10.0.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+spakky_fastapi-0.10.0.dist-info/RECORD,,

spakky_fastapi/routing.py

@@ -1,502 +0,0 @@
-from enum import Enum
-from typing import Any, Callable, Sequence, TypeAlias
-from dataclasses import dataclass
-
-from fastapi import Response, params
-from fastapi.responses import JSONResponse
-from fastapi.routing import APIRoute
-from spakky.core.annotation import FunctionAnnotation
-from spakky.core.types import FuncT
-from starlette.routing import Route as StarletteRoute
-
-SetIntStr: TypeAlias = set[int | str]
-DictIntStrAny: TypeAlias = dict[int | str, Any]
-
-
-class HTTPMethod(str, Enum):
-    GET = "GET"
-    POST = "POST"
-    PUT = "PUT"
-    PATCH = "PATCH"
-    DELETE = "DELETE"
-    HEAD = "HEAD"
-    OPTIONS = "OPTIONS"
-    TRACE = "TRACE"
-
-    def __repr__(self) -> str:
-        return self.value
-
-
-@dataclass
-class Route(FunctionAnnotation):
-    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
-    methods: set[HTTPMethod] | list[HTTPMethod] | 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
-
-
-@dataclass
-class WebSocketRoute(FunctionAnnotation):
-    path: str
-    name: str | None = None
-    dependencies: Sequence[params.Depends] | None = None
-
-
-def route(
-    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,
-    methods: set[HTTPMethod] | list[HTTPMethod] | 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]:
-    def wrapper(method: FuncT) -> FuncT:
-        return Route(
-            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,
-            route_class_override=route_class_override,
-            callbacks=callbacks,
-            openapi_extra=openapi_extra,
-        )(method)
-
-    return wrapper
-
-
-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,
-    )
-
-
-def post(
-    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.POST],
-        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,
-    )
-
-
-def put(
-    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.PUT],
-        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,
-    )
-
-
-def patch(
-    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.PATCH],
-        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,
-    )
-
-
-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,
-    )
-
-
-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,
-    )
-
-
-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,
-    )
-
-
-def websocket(
-    path: str,
-    name: str | None = None,
-    dependencies: Sequence[params.Depends] | None = None,
-) -> Callable[[FuncT], FuncT]:
-    return WebSocketRoute(
-        path=path,
-        name=name,
-        dependencies=dependencies,
-    )

spakky_fastapi-0.7.19.dist-info/RECORD

@@ -1,13 +0,0 @@
-spakky_fastapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spakky_fastapi/error.py,sha256=SWyNZk1kxbTCiy-tLxB8saLpX5rBxwvy7q7JRCtNQV0,1124
-spakky_fastapi/jwt_auth.py,sha256=Ug3DPEHQQn14gFb-j_o_NW0SUF-4NyfR67FLngjPCCQ,2822
-spakky_fastapi/middlewares/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spakky_fastapi/middlewares/error_handling.py,sha256=w_zy4PtEdGkFNN79AHh7TfwWUGSQ1JFNvPo3Dy8ojDM,1325
-spakky_fastapi/post_processor.py,sha256=33czA6PLYzNxnwQ5dKz0fXjpM_7kyMf9kaY88b_GoCI,2889
-spakky_fastapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spakky_fastapi/routing.py,sha256=3OhnnDIzaDeNhuIMWpPG17--98ti6LsgdfENsWr332g,19181
-spakky_fastapi/stereotypes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-spakky_fastapi/stereotypes/api_controller.py,sha256=hLeIYM-olZHwvFZkd1joQ-5-OQAiZXznFu4CEhrcskk,196
-spakky_fastapi-0.7.19.dist-info/METADATA,sha256=Epf3M5LlqNrHnnwrv0UDDnIuSKW4wRqo11C91P2BS38,1702
-spakky_fastapi-0.7.19.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-spakky_fastapi-0.7.19.dist-info/RECORD,,