FastAPI/Pydantic 别名现有 ORM 字段

Question

I need to point Pydantic to a different attribute when serializing an ORM model. alias= doesn't seem to work as expected. In the example below I have an ORM object with both id and uuid attributes. I want to serialize uuid as id .

The API response should be:

{
  "id": "12345678-1234-5678-1234-567812345678",
  "foo": "bar"
}

Full example:

from uuid import UUID
from fastapi import FastAPI
from pydantic import BaseModel, Field
from dataclasses import dataclass


class ApiSchema(BaseModel):
    class Config:
        orm_mode = True

    uuid: UUID = Field(alias='id')
    foo: str | None = None


@dataclass
class ORMModel:
    id: int
    uuid: UUID
    foo: str = 'bar'


app = FastAPI()

@app.get("/")
def endpoint() -> ApiSchema:
    t = ORMModel(id=1, uuid=UUID('12345678123456781234567812345678'), foo='bar')
    return t

This raises

File fastapi/routing.py", line 141, in serialize_response
    raise ValidationError(errors, field.type_)
pydantic.error_wrappers.ValidationError: 1 validation error for ApiSchema
response -> id
  value is not a valid uuid (type=type_error.uuid)

The marshmallow equivalent of what I'm trying to achieve would be this:

import marshmallow as ma

class ApiSchema(ma.Schema):
    id = ma.fields.UUID(attribute='uuid')
    foo = ma.fields.Str()

Answer 1

You misunderstand how aliases work. An alias on a field takes priority (over the actual field name) when the fields are populated . That means, during initialization, the class will look for the alias of a field in the data it is supposed to parse.

The way you defined ApiSchema , the field uuid has the alias id . Therefore, when you are parsing an instance of ORMModel (happens in FastAPI behind the scenes via ApiSchema.from_orm ), the ApiSchema class will look for an attribute named id on that ORMModel object to populate the uuid field.

Since your ORMModel actually has an attribute named id (with the value 1 in your example), its value is taken to be assigned to the uuid field of ApiSchema .

Obviously, the integer 1 is not a UUID object and can not be coerced into one, so you get that validation error telling you that the value it found for id is not a valid UUID.

Here is the problem boiled down to the essentials:

from uuid import UUID

from pydantic import BaseModel, Field, ValidationError


class ApiSchema(BaseModel):
    uuid: UUID = Field(alias='id')
    foo: str | None = None


try:
    ApiSchema.parse_obj({"uuid": "this is ignored", "foo": "bar"})
except ValidationError as exc:
    print(exc.json(indent=2))

try:
    ApiSchema.parse_obj({"id": 1, "foo": "bar"})
except ValidationError as exc:
    print(exc.json(indent=2))

The output of the first attempt:

[
  {
    "loc": [
      "id"
    ],
    "msg": "field required",
    "type": "value_error.missing"
  }
]

The second:

[
  {
    "loc": [
      "id"
    ],
    "msg": "value is not a valid uuid",
    "type": "type_error.uuid"
  }
]

---

I think you want it the other way around . I assume that your actual goal is to have a field named id on your ApiSchema model (and have that appear in your API endpoint) and alias it with uuid , so that it takes the value of the ORMModel.uuid attribute during initialization:

from uuid import UUID

from pydantic import BaseModel, Field


class ApiSchema(BaseModel):
    id: UUID = Field(alias="uuid")
    foo: str | None = None


obj = ApiSchema.parse_obj(
    {
        "id": "this is ignored",
        "uuid": UUID("12345678123456781234567812345678"),
        "foo": "bar",
    }
)
print(obj.json(indent=2))

The output:

{
  "id": "12345678-1234-5678-1234-567812345678",
  "foo": "bar"
}

---

To fix your FastAPI example, you would therefore probably do this:

from dataclasses import dataclass
from uuid import UUID

from fastapi import FastAPI
from pydantic import BaseModel, Field


class ApiSchema(BaseModel):
    id: UUID = Field(alias="uuid")
    foo: str | None = None

    class Config:
        orm_mode = True


@dataclass
class ORMModel:
    id: int
    uuid: UUID
    foo: str = "bar"


app = FastAPI()


@app.get("/", response_model=ApiSchema, response_model_by_alias=False)
def endpoint() -> ORMModel:
    t = ORMModel(id=1, uuid=UUID("12345678123456781234567812345678"), foo="bar")
    return t

Side note: Yes, the actual return type of endpoint is ORMModel . The wrapper returned by the decorator then takes that and turns it into an instance of ApiSchema via from_orm .

PS

Forgot the last part to actually get the response you want. You need to set response_model_by_alias=False in the route decorator (it is True by default) for the response to actually use the regular field name instead of the alias. I fixed the last code snipped accordingly. Now the response will be:

{"id":"12345678-1234-5678-1234-567812345678","foo":"bar"}

In the Pydantic BaseModel.json method the by_alias parameter has the value False by default. FastAPI does this differently.