Configuring request model per endpoint in FastAPI

I have a FastAPI application, in which several endpoints require the same input model, but in each, some attributes may be optional while others are required. For example:

# file: app/schemas/models.py
from pydantic import BaseModel

class GenericRequestModel(BaseModel):
    id: UUID = None      # required by all endpoints
    attr1: str = None    # required by endpoint 1 and 2, optional for 3
    attr2: boot = None   # required by 2, optional for 1, 3
    attr3: int = None    # optional by all


# file: app/api/endpoints.py
from fastapi import APIRouter

router = APIRouter(prefix='/api')


@router.post('/endpoint-1')
def endpoint_1(params: GenericRequestModel) -> ResponseModel:
    return calc_response_using_all_attrs(params)

@router.post('/endpoint-2')
def endpoint_2(params: GenericRequestModel) -> ResponseModel:
    return return calc_response_using_attrs_1_and_2(params)

@router.post('/endpoint-3')
def endpoint_3(params: GenericRequestModel) -> ResponseModel:
    return calc_generic_response(params)

Is is possible to configure GenericRequestModel's required property per endpoint, without deriving a new request models for each endpoint? If not, what is the most elegant solution?

EDIT
For completeness, here's the rationale behind my question. Assume you have many endpoints (say 50), and many attributes (100). Each endpoint may do complex stuff with the attributes and some endpoint can overcome missing data. Obviously, I don't want to create 50 different models.

The best thing that you can do here is: use inheritance. But you will need more than one model, e.g.

from typing import Optional

from pydantic import BaseModel


class RequestModelBase(BaseModel):
    id: UUID
    attr1: Optional[int]
    attr2: Optional[boot]
    attr3: Optional[int]


class RequestModel1(RequestModelBase):
    attr1: int

class RequestModel2(RequestModel1):
    attr2: boot

Then you can use:

• RequestModel1 for endpoint 1
• RequestModel2 for endpoint 2
• RequestModelBase for endpoint 3

(I hope I understood your rules for required/optional attributes correctly.)

> "Obviously, I don't want to create 50 different models."

No, that is not obvious. If your schema is different (and yes, whether an attribute is required or not is an important schematic difference), then you need to provide a different model for that schema. I am not sure what else you expect.

Smart inheritance obviously will help to reduce code duplication to a minimum. But you cannot get around defining that schematic difference somewhere.

For maximum clarity the explicit inherit-and-override approach by @Rafael-WO is ideal. This also allows you to redefine potential default values for the overridden fields.

I guess technically another alternative is to use an actual generic model and specify the different types for those varying fields dynamically in each route handler function like this:

from typing import Any, Generic, Optional, TypeVar

from pydantic.generics import GenericModel

T1 = TypeVar("T1", bound=Optional[str])
T2 = TypeVar("T2", bound=Optional[bool])


class GenericRequestModel(GenericModel, Generic[T1, T2]):
    id: int      # required by all endpoints
    attr1: T1    # required by endpoint 1 and 2, optional for 3
    attr2: T2    # required by 2, optional for 1, 3
    attr3: Optional[int] = None    # optional by all



from fastapi import FastAPI

app = FastAPI()


@app.post('/endpoint-1')
def endpoint_1(params: GenericRequestModel[str, Optional[bool]]) -> dict[str, Any]:
    return params.dict()


@app.post('/endpoint-2')
def endpoint_2(params: GenericRequestModel[str, bool]) -> dict[str, Any]:
    return params.dict()


@app.post('/endpoint-3')
def endpoint_3(params: GenericRequestModel[Optional[str], Optional[bool]]) -> dict[str, Any]:
    return params.dict()

But it is important to note that this only works in this case because an annotation like Optional[str] (or equivalent Union[str, None] or str | None) receives special treatment by the Pydantic machinery and implicitly adds None as the default value making it an optional field. (Meaning you don't have to specify attr: Optional[str] = None, the = None is technically redundant.)

So something like GenericRequestModel[Optional[str], Optional[bool]] indicates to the model that both fields attr1 and attr2 not only allow None as a value for those fields, but also that None is the default value, if no value is passed at all.

This will not work, if you want to specify any default value other than None because that default must be defined explicitly during creation of the actual model. So if you for example want attr1 to be only of type str and the field to have a default value of "abc", there is no way to express that other than by explicitly defining that in the model namespace.

Which brings us back to the inheritance-based approach.