Fixed BaseModel as a GET - method params. Added Quart.

mr-fatalyst · mr-fatalyst · commit 20ca1b090c74 · 2025-03-14T21:56:59.000+01:00
diff --git a/.coveragerc b/.coveragerc
@@ -2,7 +2,7 @@
 source = fastopenapi
 omit =
     */site-packages/*
-branch = False
+branch = True
 
 [report]
 show_missing = True
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,14 @@ All notable changes to FastOpenAPI are documented in this file.
 
 FastOpenAPI follows the [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) format.
 
+## [0.3.0] - Unreleased
+
+### Added
+- `QuartRouter` for integration with the `Quart` framework.
+
+### Fixed
+- Fixed retrieving parameters for BaseModel as arguments in GET routes.
+
 ## [0.2.1] - 2025-03-12
 
 ### Fixed
diff --git a/examples/flask/app/services/posts.py b/examples/flask/app/services/posts.py
@@ -1,4 +1,6 @@
-import falcon
+from http import HTTPStatus
+
+from flask import abort
 
 from ..schemas.posts import (
     CreatePostSchema,
@@ -14,7 +16,7 @@ def create_post(self, body: CreatePostSchema) -> PostSchema:
         post_counter = len(posts)
         author = authors.get(body.author_id)
         if not author:
-            raise falcon.HTTPNotFound(description="Author not found")
+            abort(HTTPStatus.NOT_FOUND)
 
         data = {
             "id": post_counter,
diff --git a/examples/flask/run.py b/examples/flask/run.py
@@ -7,7 +7,7 @@
 
 router = FlaskRouter(
     app=app,
-    title="MyFalconApp",
+    title="MyFlaskApp",
     version="0.0.1",
     docs_url="/docs/",
     openapi_version="3.0.0",
diff --git a/examples/quart/app/__init__.py b/examples/quart/app/__init__.py
diff --git a/examples/quart/app/api/__init__.py b/examples/quart/app/api/__init__.py
diff --git a/examples/quart/app/api/routes.py b/examples/quart/app/api/routes.py
@@ -0,0 +1,6 @@
+from fastopenapi.routers.quart import QuartRouter
+
+from .v1 import v1_router
+
+api_router = QuartRouter()
+api_router.include_router(v1_router, prefix="/v1")
diff --git a/examples/quart/app/api/v1/__init__.py b/examples/quart/app/api/v1/__init__.py
@@ -0,0 +1,8 @@
+from fastopenapi.routers.quart import QuartRouter
+
+from .authors import router as authors_router
+from .posts import router as posts_router
+
+v1_router = QuartRouter()
+v1_router.include_router(authors_router)
+v1_router.include_router(posts_router)
diff --git a/examples/quart/app/api/v1/authors.py b/examples/quart/app/api/v1/authors.py
@@ -0,0 +1,51 @@
+from http import HTTPStatus
+
+from quart import abort
+
+from fastopenapi.routers.quart import QuartRouter
+
+from ...schemas.authors import (
+    AuthorSchema,
+    CreateAuthorSchema,
+    FilterAuthorSchema,
+    UpdateAuthorSchema,
+)
+from ...services.authors import AuthorService
+
+author_service = AuthorService()
+
+router = QuartRouter()
+
+
+@router.post("/authors", tags=["Authors"], status_code=201, response_model=AuthorSchema)
+async def create_author(body: CreateAuthorSchema) -> AuthorSchema:
+    return author_service.create_author(body)
+
+
+@router.get("/authors/{author_id}", tags=["Authors"], response_model=AuthorSchema)
+async def get_author(author_id: int) -> AuthorSchema:
+    author = author_service.get_author(author_id)
+    if not author:
+        abort(HTTPStatus.NOT_FOUND)
+    return author
+
+
+@router.get("/authors/", tags=["Authors"], response_model=list[AuthorSchema])
+async def get_authors(body: FilterAuthorSchema) -> list[AuthorSchema]:
+    return author_service.get_authors(body)
+
+
+@router.delete("/authors/{author_id}", tags=["Authors"], status_code=204)
+async def delete_author(author_id: int) -> None:
+    author = author_service.delete_author(author_id)
+    if not author:
+        abort(HTTPStatus.NOT_FOUND)
+    return None
+
+
+@router.patch("/authors/{author_id}", tags=["Authors"], response_model=AuthorSchema)
+async def update_author(author_id: int, body: UpdateAuthorSchema) -> AuthorSchema:
+    author = author_service.update_author(author_id, body)
+    if not author:
+        abort(HTTPStatus.NOT_FOUND)
+    return author
diff --git a/examples/quart/app/api/v1/posts.py b/examples/quart/app/api/v1/posts.py
@@ -0,0 +1,49 @@
+from http import HTTPStatus
+
+from quart import abort
+
+from fastopenapi.routers.quart import QuartRouter
+
+from ...schemas.posts import (
+    CreatePostSchema,
+    FilterPostSchema,
+    PostSchema,
+    UpdatePostSchema,
+)
+from ...services.posts import PostService
+
+post_service = PostService()
+router = QuartRouter()
+
+
+@router.post("/posts", tags=["Posts"], status_code=201, response_model=PostSchema)
+async def create_post(body: CreatePostSchema) -> PostSchema:
+    return post_service.create_post(body)
+
+
+@router.get("/posts/{post_id}", tags=["Posts"], response_model=PostSchema)
+async def get_post(post_id: int) -> PostSchema:
+    post = post_service.get_post(post_id)
+    if not post:
+        abort(HTTPStatus.NOT_FOUND)
+    return post
+
+
+@router.get("/posts/", tags=["Posts"], response_model=list[PostSchema])
+async def get_posts(body: FilterPostSchema) -> list[PostSchema]:
+    return post_service.get_posts(body)
+
+
+@router.delete("/posts/{post_id}", tags=["Posts"], status_code=204)
+async def delete_post(post_id: int) -> None:
+    post = post_service.delete_post(post_id)
+    if not post:
+        abort(HTTPStatus.NOT_FOUND)
+
+
+@router.patch("/posts/{post_id}", tags=["Posts"], response_model=PostSchema)
+async def update_post(post_id: int, body: UpdatePostSchema) -> PostSchema:
+    post = post_service.update_post(post_id, body)
+    if not post:
+        abort(HTTPStatus.NOT_FOUND)
+    return post
diff --git a/examples/quart/app/schemas/__init__.py b/examples/quart/app/schemas/__init__.py
diff --git a/examples/quart/app/schemas/authors.py b/examples/quart/app/schemas/authors.py
@@ -0,0 +1,22 @@
+from pydantic import BaseModel, Field
+
+
+class AuthorSchema(BaseModel):
+    id: int
+    name: str
+    bio: str | None = None
+
+
+class FilterAuthorSchema(BaseModel):
+    id: int = Field(default=None)
+    name: str = Field(default=None)
+
+
+class CreateAuthorSchema(BaseModel):
+    name: str = Field(..., max_length=50)
+    bio: str | None = Field(None, max_length=200)
+
+
+class UpdateAuthorSchema(BaseModel):
+    name: str = Field(default=None, max_length=50)
+    bio: str = Field(default=None, max_length=200)
diff --git a/examples/quart/app/schemas/posts.py b/examples/quart/app/schemas/posts.py
@@ -0,0 +1,24 @@
+from pydantic import BaseModel, Field
+
+
+class PostSchema(BaseModel):
+    id: int
+    title: str
+    content: str
+    author_id: int
+
+
+class FilterPostSchema(BaseModel):
+    id: int = Field(default=None)
+    title: str = Field(default=None)
+
+
+class CreatePostSchema(BaseModel):
+    title: str = Field(..., max_length=100)
+    content: str
+    author_id: int
+
+
+class UpdatePostSchema(BaseModel):
+    title: str = Field(default=None, max_length=100)
+    content: str = Field(default=None)
diff --git a/examples/quart/app/services/__init__.py b/examples/quart/app/services/__init__.py
diff --git a/examples/quart/app/services/authors.py b/examples/quart/app/services/authors.py
@@ -0,0 +1,50 @@
+from ..schemas.authors import (
+    AuthorSchema,
+    CreateAuthorSchema,
+    FilterAuthorSchema,
+    UpdateAuthorSchema,
+)
+from ..storage import authors, posts
+
+
+class AuthorService:
+    def create_author(self, body: CreateAuthorSchema) -> AuthorSchema:
+        author_counter = len(authors)
+        data = {"id": author_counter, "name": body.name, "bio": body.bio}
+        author = AuthorSchema(**data)
+        authors[author_counter] = author
+        return author
+
+    def get_author(self, author_id: int) -> AuthorSchema | None:
+        return authors.get(author_id)
+
+    def get_authors(self, body: FilterAuthorSchema) -> list[AuthorSchema]:
+        def match(author: AuthorSchema) -> bool:
+            for field, value in body.model_dump(exclude_none=True).items():
+                if getattr(author, field) != value:
+                    return False
+            return True
+
+        return [item for _, item in authors.items() if match(item)]
+
+    def update_author(
+        self, author_id: int, body: UpdateAuthorSchema
+    ) -> AuthorSchema | None:
+        author = authors.get(author_id)
+        if author:
+            updated_author = author.copy(update=body.model_dump(exclude_unset=True))
+            authors[author_id] = updated_author
+            return updated_author
+        return None
+
+    def delete_author(self, author_id: int) -> int | None:
+        author_id = authors.pop(author_id, None)
+        if author_id:
+            keys_to_remove = [
+                post_id
+                for post_id, post in posts.items()
+                if post.author_id == author_id.id
+            ]
+            for key in keys_to_remove:
+                del posts[key]
+        return author_id
diff --git a/examples/quart/app/services/posts.py b/examples/quart/app/services/posts.py
@@ -0,0 +1,52 @@
+from http import HTTPStatus
+
+from quart import abort
+
+from ..schemas.posts import (
+    CreatePostSchema,
+    FilterPostSchema,
+    PostSchema,
+    UpdatePostSchema,
+)
+from ..storage import authors, posts
+
+
+class PostService:
+    def create_post(self, body: CreatePostSchema) -> PostSchema:
+        post_counter = len(posts)
+        author = authors.get(body.author_id)
+        if not author:
+            abort(HTTPStatus.NOT_FOUND)
+
+        data = {
+            "id": post_counter,
+            "title": body.title,
+            "content": body.content,
+            "author_id": body.author_id,
+        }
+        post = PostSchema(**data)
+        posts[post_counter] = post
+        return post
+
+    def get_post(self, post_id: int) -> PostSchema | None:
+        return posts.get(post_id)
+
+    def get_posts(self, body: FilterPostSchema) -> list[PostSchema]:
+        def match(post: PostSchema) -> bool:
+            for field, value in body.model_dump(exclude_none=True).items():
+                if getattr(post, field) != value:
+                    return False
+            return True
+
+        return [item for _, item in posts.items() if match(item)]
+
+    def update_post(self, post_id: int, body: UpdatePostSchema) -> PostSchema | None:
+        post = posts.get(post_id)
+        if post:
+            updated_post = post.copy(update=body.model_dump(exclude_unset=True))
+            posts[post_id] = updated_post
+            return updated_post
+        return None
+
+    def delete_post(self, post_id: int) -> int | None:
+        return posts.pop(post_id, None)
diff --git a/examples/quart/app/storage.py b/examples/quart/app/storage.py
@@ -0,0 +1,2 @@
+authors = {}
+posts = {}
diff --git a/examples/quart/run.py b/examples/quart/run.py
@@ -0,0 +1,19 @@
+from app.api.routes import api_router
+from quart import Quart
+
+from fastopenapi.routers.quart import QuartRouter
+
+app = Quart(__name__)
+
+router = QuartRouter(
+    app=app,
+    title="MyQuartApp",
+    version="0.0.1",
+    docs_url="/docs/",
+    openapi_version="3.0.0",
+)
+router.include_router(api_router, prefix="/api")
+
+
+if __name__ == "__main__":
+    app.run(debug=True, port=8000)
diff --git a/examples/quart_example.py b/examples/quart_example.py
@@ -0,0 +1,21 @@
+from pydantic import BaseModel
+from quart import Quart
+
+from fastopenapi.routers.quart import QuartRouter
+
+app = Quart(__name__)
+router = QuartRouter(app=app, docs_url="/docs/", openapi_version="3.0.0")
+
+
+class HelloResponse(BaseModel):
+    message: str
+
+
+@router.get("/hello", tags=["Hello"], status_code=200, response_model=HelloResponse)
+def hello(name: str):
+    """Say hello from Quart"""
+    return HelloResponse(message=f"Hello, {name}! It's Quart!")
+
+
+if __name__ == "__main__":
+    app.run(debug=True, port=8000)
diff --git a/fastopenapi/base_router.py b/fastopenapi/base_router.py
@@ -306,7 +306,8 @@ def resolve_endpoint_params(
             is_required = param.default is inspect.Parameter.empty
             if isinstance(annotation, type) and issubclass(annotation, BaseModel):
                 try:
-                    kwargs[name] = annotation(**body)
+                    params = body if body else all_params
+                    kwargs[name] = annotation(**params)
                 except Exception as e:
                     raise ValueError(f"Validation error for parameter '{name}': {e}")
             else:
diff --git a/fastopenapi/routers/quart.py b/fastopenapi/routers/quart.py
diff --git a/pyproject.toml b/pyproject.toml
