Use pydantic model saved in __init__ to check request input in a __call__ dependency

[dreinon]

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.
• 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:

##############################
# file models.py

from pydantic import BaseModel


class ExampleModel(BaseModel):
    example: str


##############################
# file dependencies.py

from pydantic import BaseModel


class ExampleClass:
    # BaseModel just for editor suggestions, model will always be a class inherited from BaseModel, A.K.A a pydantic model
    def __init__(self, model: BaseModel) -> None:
        self.model = model

    async def __call__(self, input: self.model):
        return 'Hello, this is an example. An 422 should be raised if input doesn't match the model'


##############################
# file api.py
from .dependencies import ExampleClass
from .models import ExampleModel


example_dependency = ExampleClass(ExampleModel)

@router.post('/')
async def example_endpoint(payload = Depends(example_dependency)):
    return payload

Description

My question is in file dependencies.py at call method, I cannot use self.model as a type hint because self is not defined yet, but I want this method to automatically return the 422 FastAPI returns when a model is not matched.

The reason why I'm not directly using the ExampleModel itself is that I want ExampleClass to be independent of the input, so I can reuse it as a dependency for multiple methods.

Environment

• OS: Linux Kubuntu
• FastAPI Version: 0.65.1
• Python version: 3.9.4

[uolot]

You could try declaring a TypeVar to make the ExampleClass generic.

from typing import Type, TypeVar

from fastapi import APIRouter, Depends
from pydantic import BaseModel

router = APIRouter()

T = TypeVar("T", bound=BaseModel)


class ExampleModel(BaseModel):
    example: str


class ExampleClass:
    # BaseModel just for editor suggestions, model will always be a class
    # inherited from BaseModel, A.K.A a pydantic model
    def __init__(self, model: Type[T]) -> None:
        self.model = model

    async def __call__(self, input: Type[T]):
        return (
            "Hello, this is an example. An 422 should be raised if input "
            "doesn't match the model"
        )


example_dependency = ExampleClass(ExampleModel)


@router.post("/")
async def example_endpoint(payload=Depends(example_dependency)):
    return payload

[dreinon]

Hey @uolot! Thanks for answering. I have some doubts, maybe because I'm not used to work with TypeVar.
I understand that in __init__, model can be any pydantic model. Although, in __call__, we would just be checking if input is again any kind of pydantic model, right?
My objective is not to ensure that input matches any pydantic model, it's actually to ensure input matches the model I declared in __init__

[uolot]

That's exactly what a TypeVar does. It makes the class (or function generic). Its bound argument denotes the base type, that the objects passed to class methods have to subclass. What the code above does is give or take:

• declare a new generic type T that is bound by pydantic's BaseModel
• the model in ExampleClass.__init__ has to be a sublass of BaseModel
• the input in ExampleClass.__call__ has to be of the same type as the model from previous step

In the example code I posted I get use the type of the generic type, which means this calls will pass mypy checks:

• ExampleClass(ExampleModel)
• ExampleClass()(ExampleModel)

If you want to pass an instance of ExampleModel to ExampleClass.__call__, remove the change input type to T (without Type), then this will work:

• ExampleClass(ExampleModel)
• ExampleClass()(ExampleModel())

[dreinon]

Thanks @uolot! I don't exactly understand why, but input is only being checked if I use Type[T] in __call__ if I use Tit doesn't check, I understand it's because FastAPI request input is not an instance of a Pydantic Model but the model itself.

Although, if I name the parameter of my __call__ method input, pydantic is asking for an input query parameter and returning 422:

{
  "detail": [
    {
      "loc": [
        "query",
        "input"
      ],
      "msg": "field required",
      "type": "value_error.missing"
    }
  ]
}

Nevertheless, if I use Body(...)to indicate this parameter comes from the body of the request, then it doesn't get converted to a pydantic model.

[uolot]

To get the validation working you need to either declare the response_model in your router.post decorator, or return a wrapped object from the endpoint, for example return MyModel(payload). Or do it inside your dependency class.

Regarding your second issue, it would be helpful if you provide more code and show how exactly you call that endpoint.

[dreinon]

You could try declaring a TypeVar to make the ExampleClass generic.

from typing import Type, TypeVar

from fastapi import APIRouter, Depends
from pydantic import BaseModel

router = APIRouter()

T = TypeVar("T", bound=BaseModel)


class ExampleModel(BaseModel):
    example: str


class ExampleClass:
    # BaseModel just for editor suggestions, model will always be a class
    # inherited from BaseModel, A.K.A a pydantic model
    def __init__(self, model: Type[T]) -> None:
        self.model = model

    async def __call__(self, input: Type[T]):
        return (
            "Hello, this is an example. An 422 should be raised if input "
            "doesn't match the model"
        )


example_dependency = ExampleClass(ExampleModel)


@router.post("/")
async def example_endpoint(payload=Depends(example_dependency)):
    return payload

Using this code, call / with payload

{
    "example": "value"
}

and you will get a 422 response with the following message:

{
  "detail": [
    {
      "loc": [
        "query",
        "input"
      ],
      "msg": "field required",
      "type": "value_error.missing"
    }
  ]
}

which is asking for a query parameter called input. This is due to the way FastAPI recognises parameters, which according to the docs is:

The function parameters will be recognized as follows:

1. If the parameter is also declared in the path, it will be used as a path parameter.
2. If the parameter is of a singular type (like int, float, str, bool, etc) it will be interpreted as a query parameter.
3. If the parameter is declared to be of the type of a Pydantic model, it will be interpreted as a request body.

Since T is a custom type, pydantic is recognising it as a query parameter (2), even though T is actually a pydantic model, and thus, it should be recognised as the request body (3).

[dreinon]

Closing this issue because a new one has been opened to discuss the specific topic.