Instances of generic types with bound=BaseModel are not serialised

[carlosds731]

Initial Checks

• I confirm that I'm using Pydantic V2

Description

I have an Error class that optionally includes details, which should be a subclass of Pydantic's BaseModel. My aim is to specify the type of these details. Here's how I've implemented it:

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

class Error(BaseModel, Generic[ErrorDataT]):
    message: str
    details: Optional[ErrorDataT]

With this, the details field is strongly typed and ensures that, if present, it's always an instance of Pydantic's BaseModel. However, when I call error.model_dump(), the details field serializes as an empty dictionary. Removing the bound constraint on ErrorDataT allows the model to serialize correctly, but at the expense of type validation, i.e., I can assign any value to error.details.

In the tests provided below, both should ideally pass. But currently, only one of them does based on the bound constraint:

• With the constraint:test_can_not_use_non_base_models_as_error_details passes, buttest_sample_error_is_correctly_serialized fails.
• Without the constraint:test_sample_error_is_correctly_serialized passes, buttest_can_not_use_non_base_models_as_error_details fails.

NOTE: This was working in v1 (using GenericModel). I apologize in advance if I didn't understand something while doing the migration from v1 to v2.

Example Code

from pydantic import BaseModel, ValidationError
from typing import TypeVar, Generic, Optional
import pytest

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


class ErrorDetails(BaseModel):
    foo: str


class ErrorDetailsNonBaseModel:
    other: str

    def __init__(self, other) -> None:
        self.other = other


class Error(BaseModel, Generic[ErrorDataT]):
    message: str
    details: Optional[ErrorDataT]


sample_error = Error(
    message="We just had an error",
    details=ErrorDetails(foo="var"),
)


class TestApiErrorResponse:
    def test_sample_error_is_correctly_serialized(self):
        assert sample_error.model_dump() == {
            "message": "We just had an error",
            "details": {
                "foo": "var",
            },
        }

    def test_can_not_use_non_base_models_as_error_details(self):
        with pytest.raises(ValidationError):
            Error(
                message="We just had an error",
                details=ErrorDetailsNonBaseModel(other="some value"),
            )

Python, Pydantic & OS Version

pydantic version: 2.3.0
        pydantic-core version: 2.6.3
          pydantic-core build: profile=release pgo=false
                 install path: /Users/carlos/.virtualenvs/pydantic-issue/lib/python3.10/site-packages/pydantic
               python version: 3.10.8 (v3.10.8:aaaf517424, Oct 11 2022, 10:14:40) [Clang 13.0.0 (clang-1300.0.29.30)]
                     platform: macOS-13.5.1-arm64-arm-64bit
     optional deps. installed: ['typing-extensions']

[sydney-runkle]

Hi @carlosds731,

Thanks for your question! The current issue you're having is due to the fact that you haven't specified the generic parameter type when you instantiate the Error class.

If you do the following, your tests pass:

from pydantic import BaseModel, ValidationError
from typing import TypeVar, Generic, Optional
import pytest

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


class ErrorDetails(BaseModel):
    foo: str


class ErrorDetailsNonBaseModel:
    other: str

    def __init__(self, other) -> None:
        self.other = other


class Error(BaseModel, Generic[ErrorDataT]):
    message: str
    details: Optional[ErrorDataT]


sample_error = Error[ErrorDetails](
    message="We just had an error",
    details=ErrorDetails(foo="var"),
)

The reason for this is that we default to serializing with the bound type of a TypeVar if the type being used for a generic isn't specified.

Another approach that you could use is this:

from pydantic import BaseModel, SerializeAsAny
from typing import TypeVar, Generic, Optional
​
ErrorDataT = TypeVar("ErrorDataT", bound=BaseModel)
​
​
class ErrorDetails(BaseModel):
    foo: str
​
​
class Error(BaseModel, Generic[ErrorDataT]):
    message: str
    details: Optional[SerializeAsAny[ErrorDataT]]
​
​
sample_error = Error(
    message="We just had an error",
    details=ErrorDetails(foo="var"),
)

Using the SerializeAsAny flag makes it such that whatever type ErrorDataT takes on, it's serialized as an Any type, but validated still against the ErrorDataT type schema.

All of this being said, we think that this behavior is confusing, so we've opened the PR mentioned above to fix this issue (so the original code you have should work, once that change is released).

[carlosds731]

thank you very much @sydney-runkle