Merge pull request #3 from dotX12/dev_query

Added support query model.

Author: dotX12

examples/main.py

@@ -2,9 +2,12 @@
 from fastapi import File
 from fastapi import UploadFile
 
-from examples.models import PostContractJSONSchema, PostContractBodySchema
+from examples.models import PostContractBodySchema
+from examples.models import PostContractJSONSchema
 from examples.models import PostContractSmallDoubleBodySchema
+from examples.models import PostContractSmallDoubleQuerySchema
 from pyfa_converter import FormBody
+from pyfa_converter.depends import QueryBody
 
 app = FastAPI()
 
@@ -24,27 +27,30 @@ async def example_foo_body_handler(
     data: PostContractBodySchema = FormBody(PostContractBodySchema),
     document: UploadFile = File(...),
 ):
-    return {
-        "title": data.title,
-        "date": data.date,
-        "file_name": document.filename
-    }
+    return {"title": data.title, "date": data.date, "file_name": document.filename}
 
 
 @app.post("/form-data-body-two")
 async def example_foo_body_handler(
     data: PostContractBodySchema = FormBody(PostContractBodySchema),
     document: UploadFile = File(...),
 ):
-    return {
-        "title": data.title,
-        "date": data.date,
-        "file_name": document.filename
-    }
+    return {"title": data.title, "date": data.date, "file_name": document.filename}
 
 
 @app.post("/test")
 async def foo(
-    data: PostContractSmallDoubleBodySchema = FormBody(PostContractSmallDoubleBodySchema),
+    data: PostContractSmallDoubleBodySchema = FormBody(
+        PostContractSmallDoubleBodySchema
+    ),
+):
+    return {"bar": "bar"}
+
+
+@app.post("/test_query_list")
+async def test_list_form(
+    data: PostContractSmallDoubleQuerySchema = QueryBody(
+        PostContractSmallDoubleQuerySchema
+    ),
 ):
-    return {'bar': 'bar'}
+    return {"data": data}

examples/models.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 from decimal import Decimal
+from typing import List
 from typing import Optional
 
 from pydantic import BaseModel
@@ -17,7 +18,7 @@ class PostContractJSONSchema(BaseModel):
     amount: Optional[Decimal] = Field(None, description="Description amount")
     unit_price: Optional[Decimal] = Field(None, description="Description unit_price")
 
-    @validator('date', each_item=True)
+    @validator("date", each_item=True)
     def date_validator(cls, v: datetime):
         return v.date()
 
@@ -41,5 +42,13 @@ class PostContractSmallBodySchema(PostContractSmallJSONSchema):
 
 @PydanticConverter.body
 class PostContractSmallDoubleBodySchema(BaseModel):
-    id: Optional[int] = Field(None, description='gwa')
+    id: Optional[int] = Field(None, description="gwa")
     title: Optional[str] = Field(None)
+    data: Optional[List[int]]
+
+
+@PydanticConverter.query
+class PostContractSmallDoubleQuerySchema(BaseModel):
+    id: Optional[int] = Field(None, description="gwa")
+    title: Optional[str] = Field(None)
+    data: Optional[List[int]] = Field(default=[1, 2, 3])

pyfa_converter/__init__.py

@@ -2,6 +2,6 @@
 from .depends import FormBody
 
 __all__ = (
-    'PydanticConverter',
-    'FormBody',
+    "PydanticConverter",
+    "FormBody",
 )

pyfa_converter/depends.py

@@ -8,3 +8,8 @@
 class FormBody:
     def __new__(cls, model_type: Type[BaseModel | PydanticConverter]):
         return Depends(model_type.body)
+
+
+class QueryBody:
+    def __new__(cls, model_type: Type[BaseModel | PydanticConverter]):
+        return Depends(model_type.query)

pyfa_converter/utils.py

@@ -1,10 +1,14 @@
 import inspect
 from typing import Any
+from typing import Callable
+from typing import List
 from typing import Type
+from typing import Union
 
 from fastapi import Body
 from fastapi import Depends
 from fastapi import Form
+from fastapi import Query
 from pydantic import BaseModel
 from pydantic.fields import ModelField
 
@@ -13,12 +17,27 @@ class PydanticConverterUtils:
     @classmethod
     def form(cls, field: ModelField) -> Body:
         if field.required is True:
-            return cls.__form(model_field=field, default=...)
-        return cls.__form(model_field=field, default=field.default)
+            return cls.__fill_params(param=Form, model_field=field, default=...)
+        return cls.__fill_params(param=Form, model_field=field, default=field.default)
 
     @classmethod
-    def __form(cls, model_field: ModelField, default: Any):
-        return Form(
+    def query(cls, field: ModelField) -> Body:
+        if field.required is True:
+            return cls.__fill_params(param=Query, model_field=field, default=...)
+        return cls.__fill_params(param=Query, model_field=field, default=field.default)
+
+    @classmethod
+    def __base_param(cls, field: ModelField, param: Union[Form, Query]):
+        if type(param) is Form:
+            return cls.form(field=field)
+        if type(param) is Query:
+            return cls.query(field=field)
+
+    @classmethod
+    def __fill_params(
+        cls, param: Union[Form, Query], model_field: ModelField, default: Any
+    ):
+        return param(
             default=default or None,
             alias=model_field.alias or None,
             title=model_field.field_info.title or None,
@@ -32,9 +51,22 @@ def __form(cls, model_field: ModelField, default: Any):
             regex=model_field.field_info.regex or None,
         )
 
+    @classmethod
+    def override_signature_parameters(
+        cls, model: Type[BaseModel], param_maker: Callable[[ModelField], Any]
+    ):
+        return [
+            inspect.Parameter(
+                field.alias,
+                inspect.Parameter.POSITIONAL_ONLY,
+                default=param_maker(field),
+                annotation=field.outer_type_,
+            )
+            for field in model.__fields__.values()
+        ]
 
-class PydanticConverter:
 
+class PydanticConverter:
     @staticmethod
     def body(cls: Type[BaseModel]) -> Type[BaseModel]:
         """
@@ -67,18 +99,13 @@ def make_form_parameter(field: ModelField) -> Any:
                     f"Sub-model class for {field.name} field must be decorated with"
                     f" `as_form` too."
                 )
-                return Depends(field.type_.body) # noqa
+                return Depends(field.type_.body)  # noqa
             else:
                 return PydanticConverterUtils.form(field=field)
 
-        new_params = [
-            inspect.Parameter(
-                field.alias,
-                inspect.Parameter.POSITIONAL_ONLY,
-                default=make_form_parameter(field),
-            )
-            for field in cls.__fields__.values()
-        ]
+        new_params = PydanticConverterUtils.override_signature_parameters(
+            model=cls, param_maker=make_form_parameter
+        )
 
         async def _as_form(**data):
             return cls(**data)
@@ -89,3 +116,51 @@ async def _as_form(**data):
         setattr(cls, "body", _as_form)
         return cls
 
+    @staticmethod
+    def query(cls: Type[BaseModel]) -> Type[BaseModel]:
+        """
+        Adds an `body` class method to decorated models. The `query` class
+        method can be used with `FastAPI` endpoints.
+
+        Args:
+            cls: The model class to decorate.
+
+        Returns:
+            The decorated class.
+        """
+
+        def make_form_parameter(field: ModelField) -> Any:
+            """
+            Converts a field from a `Pydantic` model to the appropriate `FastAPI`
+            parameter type.
+
+            Args:
+                field: The field to convert.
+
+            Returns:
+                Either the result of `Form`, if the field is not a sub-model, or
+                the result of `Depends` if it is.
+
+            """
+            if issubclass(field.type_, BaseModel):
+                # This is a sub-model.
+                assert hasattr(field.type_, "query"), (
+                    f"Sub-model class for {field.name} field must be decorated with"
+                    f" `as_form` too."
+                )
+                return Depends(field.type_.query)  # noqa
+            else:
+                return PydanticConverterUtils.query(field=field)
+
+        new_params = PydanticConverterUtils.override_signature_parameters(
+            model=cls, param_maker=make_form_parameter
+        )
+
+        async def _as_form(**data):
+            return cls(**data)
+
+        sig = inspect.signature(_as_form)
+        sig = sig.replace(parameters=new_params)
+        _as_form.__signature__ = sig
+        setattr(cls, "query", _as_form)
+        return cls