What does the update argument to model_validate do, and am I using it correctly?

[MatMoore]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the SQLModel documentation, with the integrated search.
• I already searched in Google "How to X in SQLModel" 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 SQLModel but to Pydantic.
• I already checked if it is not related to SQLModel but to SQLAlchemy.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from sqlmodel import SQLModel


class A(SQLModel):
    foo: str


class B(A):
    bar: str


a = A(foo="a")
print(a)  # > foo='a'

# A cannot be validated as B, because it is missing a field
# b = B.model_validate(a)

# This throws a RecursionError
b = B.model_validate(a, update={"bar": "b"})
print(b)

Description

Hi, I'm new to SQLModel.

From reading the tutorial I gather that model_validate can be used to map between different classes of model that share common fields. So if I have an instance of a model that has been deserialised from some JSON, I can then map that to an ORM model even if the set of fields are slightly different(?)

However I'm confused about how to use this in practice. I noticed that the method takes an optional update argument.

    @classmethod
    def model_validate(
        cls: Type[_TSQLModel],
        obj: Any,
        *,
        strict: Union[bool, None] = None,
        from_attributes: Union[bool, None] = None,
        context: Union[Dict[str, Any], None] = None,
        update: Union[Dict[str, Any], None] = None,
    ) -> _TSQLModel:
        return sqlmodel_validate(
            cls=cls,
            obj=obj,
            strict=strict,
            from_attributes=from_attributes,
            context=context,
            update=update,
        )

This is undocumented, but in #523 somebody mentioned that update can be used to

create a new object in an API call from a client, but then add more values to the DB type using some logic in my endpoint function.

I was hoping this meant I could call pass a dictionary to model_validate that would override certain fields that I don't expect to come from the other model.

However when I run the code above, I get an unexpected RecursionError:

pydantic_core._pydantic_core.ValidationError: 2 validation errors for B
foo
  Error extracting attribute: RecursionError: maximum recursion depth exceeded [type=get_attribute_error, input_value=<unprintable ObjectWithUpdateWrapper object>, input_type=ObjectWithUpdateWrapper]
    For further information visit https://errors.pydantic.dev/2.5/v/get_attribute_error
bar
  Error extracting attribute: RecursionError: maximum recursion depth exceeded [type=get_attribute_error, input_value=<unprintable ObjectWithUpdateWrapper object>, input_type=ObjectWithUpdateWrapper]
    For further information visit https://errors.pydantic.dev/2.5/v/get_attribute_error

Operating System

macOS

Operating System Details

No response

SQLModel Version

0.0.14

Python Version

Python 3.11.5

Additional Context

No response

[taranlu-houzz]

@MatMoore I just ran into this as well. From digging into things, it looks when you pass a model along with the update param, it creates a ObjectWithUpdateWrapper which is what actually gets validated:

    def sqlmodel_validate(
        cls: Type[_TSQLModel],
        obj: Any,
        *,
        strict: Union[bool, None] = None,
        from_attributes: Union[bool, None] = None,
        context: Union[Dict[str, Any], None] = None,
        update: Union[Dict[str, Any], None] = None,
    ) -> _TSQLModel:
        if not is_table_model_class(cls):
            new_obj: _TSQLModel = cls.__new__(cls)
        else:
            # If table, create the new instance normally to make SQLAlchemy create
            # the _sa_instance_state attribute
            # The wrapper of this function should use with _partial_init()
            with partial_init():
                new_obj = cls()
        # SQLModel Override to get class SQLAlchemy __dict__ attributes and
        # set them back in after creating the object
        old_dict = new_obj.__dict__.copy()
        use_obj = obj
        if isinstance(obj, dict) and update:
            use_obj = {**obj, **update}
        elif update:
            use_obj = ObjectWithUpdateWrapper(obj=obj, update=update)
        cls.__pydantic_validator__.validate_python(
            use_obj,
            strict=strict,
            from_attributes=from_attributes,
            context=context,
            self_instance=new_obj,
        )

Unfortunately, it seems that there is a bug, because as the validator is running, it tries to check for an attribute called update instead of the key names inside of the update parameter that was passed:

@dataclass
class ObjectWithUpdateWrapper:
    obj: Any
    update: Dict[str, Any]

    def __getattribute__(self, __name: str) -> Any:  # NOTE: Recursion occurs when `__name` is "update".
        if __name in self.update:
            return self.update[__name]
        return getattr(self.obj, __name)

That being said, it seems like a workaround might be to to dump the model as a dict and use that instead (since it would not cause the ObjectWithUpdateWrapper to be created which seems to be where the issues lies):

from sqlmodel import SQLModel


class A(SQLModel):
    foo: str


class B(A):
    bar: str


a = A(foo="a")
print(a)  # > foo='a'

# A cannot be validated as B, because it is missing a field
# b = B.model_validate(a)

# Possible workaround?
b = B.model_validate(a.model_dump(), update={"bar": "b"})
print(b)

[nathan-osman]

This is very helpful! I also discovered that downgrading to Pydantic v1 avoids this issue (if that's an option in your case).