Multiple use of forms: fastapi/fastapi#2387 (comment)

Author: dotX12

examples/main.py

@@ -1,8 +1,9 @@
-from fastapi import FastAPI, Depends
+from fastapi import FastAPI
 from fastapi import File
 from fastapi import UploadFile
 
 from examples.models import PostContractJSONSchema, PostContractBodySchema
+from examples.models import PostContractSmallDoubleBodySchema
 from pyfa_converter import FormBody
 
 app = FastAPI()
@@ -20,7 +21,7 @@ async def example_json_body_handler(
 
 @app.post("/form-data-body")
 async def example_foo_body_handler(
-    data: PostContractBodySchema = FormBody(),
+    data: PostContractBodySchema = FormBody(PostContractBodySchema),
     document: UploadFile = File(...),
 ):
     return {
@@ -32,11 +33,18 @@ async def example_foo_body_handler(
 
 @app.post("/form-data-body-two")
 async def example_foo_body_handler(
-    data: PostContractBodySchema = FormBody(),
+    data: PostContractBodySchema = FormBody(PostContractBodySchema),
     document: UploadFile = File(...),
 ):
     return {
         "title": data.title,
         "date": data.date,
         "file_name": document.filename
-    }
+    }
+
+
+@app.post("/test")
+async def foo(
+    data: PostContractSmallDoubleBodySchema = FormBody(PostContractSmallDoubleBodySchema),
+):
+    return {'bar': 'bar'}

examples/models.py

@@ -40,5 +40,6 @@ class PostContractSmallBodySchema(PostContractSmallJSONSchema):
 
 
 @PydanticConverter.body
-class PostContractSmallDoubleBodySchema(PostContractSmallJSONSchema):
-    pass
+class PostContractSmallDoubleBodySchema(BaseModel):
+    id: Optional[int] = Field(None, description='gwa')
+    title: Optional[str] = Field(None)

pyfa_converter/depends.py

@@ -1,7 +1,10 @@
+from typing import Type
 from fastapi import Depends
+from pydantic import BaseModel
+
 from pyfa_converter import PydanticConverter
 
 
 class FormBody:
-    def __new__(cls):
-        return Depends(PydanticConverter.body)
+    def __new__(cls, model_type: Type[BaseModel | PydanticConverter]):
+        return Depends(model_type.body)

pyfa_converter/utils.py

@@ -3,13 +3,13 @@
 from typing import Type
 
 from fastapi import Body
+from fastapi import Depends
 from fastapi import Form
 from pydantic import BaseModel
 from pydantic.fields import ModelField
 
 
-class PydanticConverter:
-
+class PydanticConverterUtils:
     @classmethod
     def form(cls, field: ModelField) -> Body:
         if field.required is True:
@@ -32,28 +32,60 @@ def __form(cls, model_field: ModelField, default: Any):
             regex=model_field.field_info.regex or None,
         )
 
-    @classmethod
-    def body(cls, parent_cls: Type[BaseModel]):
-        new_parameters = []
-
-        for field_name, model_field in parent_cls.__fields__.items():
-            model_field: ModelField
-
-            new_parameters.append(
-                inspect.Parameter(
-                    field_name,
-                    inspect.Parameter.POSITIONAL_ONLY,
-                    default=cls.form(field=model_field),
-                    annotation=model_field.outer_type_,
+
+class PydanticConverter:
+
+    @staticmethod
+    def body(cls: Type[BaseModel]) -> Type[BaseModel]:
+        """
+        Adds an `body` class method to decorated models. The `body` 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_, "body"), (
+                    f"Sub-model class for {field.name} field must be decorated with"
+                    f" `as_form` too."
                 )
+                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()
+        ]
 
-        def as_form_func(*args, **kwargs):
-            return parent_cls(*args, **kwargs)  # noqa
+        async def _as_form(**data):
+            return cls(**data)
 
-        sig = inspect.signature(as_form_func)
-        sig = sig.replace(parameters=new_parameters)
-        as_form_func.__signature__ = sig
-        setattr(cls, 'body', as_form_func)
+        sig = inspect.signature(_as_form)
+        sig = sig.replace(parameters=new_params)
+        _as_form.__signature__ = sig
+        setattr(cls, "body", _as_form)
         return cls