Issue 1:
Is your feature request related to a problem

I wish to use pydantic's BaseModel with validators as depency injection. Classes as dependencies are handy because I can fuse multiple path/body/... parameters into a single object, but what would be cool is to be able to check those parameters based on other parameters via pydantic's validators even if those values are transferred in different forms (path/body/...).

The solution you would like

So, what already works is something like this:

class User(BaseModel):
name: str
password: str
age: int = Query(None)

@app.get('/users/{name}/{password}')
async def fetch(user: User = Depends()):
return user

This correctly checks types and benefits from the usual genius automatic error and documentation generation. Though, adding validators to e.g. make sure the user's name is not the same as her password leads to an internal server error when the ValueError is raised.

class User(BaseModel):
name: str
password: str
age: int = Query(None)

@validator('password')
def check_not_equal(cls, v, values):
if v == values['name']:
raise ValueError('name and password match')
return v

@app.get('/users/{name}/{password}')
async def fetch(user: User = Depends()):
return user

The optimal thing would be that those validators work even when used inside a dependency. The main benefit is that this would allow me to validate values based on other values even if those values are transferred in different forms (path/body/...).

Describe alternatives you've considered

The alternative is to not do the validation in the dependency, but afterwards.

Additional context

Thank you for your work on this framework, FastAPI is super cool! 😎

Issue 2:
First check

I added a very descriptive title to this issue.

I used the GitHub search to find a similar issue and didn't find it. - See additional context

I searched the FastAPI documentation, with the integrated search.

I already searched in Google "How to X in FastAPI" and didn't find any information.

I already read and followed all the tutorial in the docs and didn't find an answer.

I already checked if it is not related to FastAPI but to Pydantic.

I already checked if it is not related to FastAPI but to Swagger UI.

I already checked if it is not related to FastAPI but to ReDoc.

After submitting this, I commit to one of:

Read open issues with questions until I find 2 issues where I can help someone and add a comment to help there.

I already hit the "watch" button in this repository to receive notifications and I commit to help at least 2 people that ask questions in the future.

Implement a Pull Request for a confirmed bug.

Example

Here's a self-contained, minimal, reproducible, example with my use case:

import inspect
from typing import Dict, Type

from fastapi import Depends, FastAPI, File, Form
from pydantic import BaseModel

app = FastAPI()

def as_form(cls: Type[BaseModel]):
"""
Adds an as_form class method to decorated models. The as_form class method
can be used with FastAPI endpoints
"""
new_params = [
inspect.Parameter(
field.alias,
inspect.Parameter.POSITIONAL_ONLY,
default=(Form(field.default) if not field.required else Form(...)),
annotation=field.outer_type_,
)
for field in cls.__fields__.values()
]

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, "as_form", _as_form)
return cls

@as_form
class Item(BaseModel):
name: str
another: str
opts: Dict[str, int] = {}

@app.post("/test", response_model=Item)
def endpoint(item: Item = Depends(Item.as_form), data: bytes = File(...)):
print(len(data))
return item

if __name__ == "__main__":
import json
import os

from fastapi.testclient import TestClient

tc = TestClient(app)

item = {"name": "vivalldi", "another": "mause"}

data = bytearray(os.urandom(1))
files = {"data": ("data", data, "text/csv")}

r = tc.post("/test", data=item, files=files)
assert r.status_code == 200
assert r.json() == {"name": "vivalldi", "another": "mause", "opts": {}}

files["opts"] = (None, json.dumps({"a": 2}), "application/json")
r = tc.post("/test", data=item, files=files)
assert r.status_code == 200
assert r.json() == {"name": "vivalldi", "another": "mause", "opts": {"a": 2}}

Description

tl;dr

Complex data types (objects) are not supported in multipart/form-data by FastAPI. There are workarounds for top level fields in pydantic models; nested objects are not supported. Save the above script as nested.py. Run python ./nested.py to see failing assertions. And call uvicorn nested:app to run the FastAPI app locally. Local tests can be run using httpie script in this gist

full

If you look through the StackOverflow & FastAPI issues you'll find plenty of examples of how to convert a model into a form. This issue is to address the shortcomings of those workarounds. The main focus of this is to determine the best way to work with multi-content multipart/form-data requests.

Per the OpenAPI Special Considerations for multipart Content "boundaries MAY be used to separate sections of the content being transferred." This indicates that you can specify the content type of each individual part. An example of a combination multipart request can be found in this gist. The gist was generated using httpie.

Going forward I intend to investigate what can be done from a workaround standpoint. Initially, I think we can adjust the workarounds to set object types to a File and parse those files as JSON (might require some model tweaks as well). Additionally, if this issue gains traction I will look into making changes that allow FastAPI to better support multi-content multipart requests.

Environment

OS: macOS

FastAPI Version: 0.58.1

Python version: 3.8.6

Additional context

This is a spin-off of #2365 at Mause's request

Since the root cause is complex types (objects) in forms aren't supported, this may be a duplicate of #2295