Change the representation of Pydantic models to enable the use of dirty_equals.

[15r10nk]

Implement a custom matcher which can be used to represent pydantic models.

features:

• Model can be refactored and attributes can be added/removed. The tests will fail but inline-snapshot can fix them because == returns False.
• dirty-equals can be used as arguments
• This new code can be generated by default with the new @customize hook

from pydantic import BaseModel

from inline_snapshot import snapshot

class IsPydantic:
    def __init__(self,typ,/,**attributes):
        self.typ=typ
        self.attributes=attributes

    def __eq__(self,other):
        if type(other) is not self.typ:
            return NotImplemented

        for name,attribute in self.attributes.items():
            if not hasattr(other,name):
                return False
            if not getattr(other,name) == attribute:
                return False

        # todo: we have to check that missing attributes are equal to the default value

        return True

class M(BaseModel):
    x:int
    y:int

def test_is_pydantic():

    # old style
    assert M(x=1,y=2) == snapshot(M(x=1,y=2))

    # proposed new style
    assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2))

    # can handle invalid arguments (return False and raise no exception)
    assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2,invalid=5))

[alexmojaki]

Turns out this already works:

import dataclasses
from dirty_equals import IsInstance, HasAttributes


@dataclasses.dataclass
class TestData:
    id: int
    name: str
    value: float


assert TestData(id=1, name="test", value=3.14) == IsInstance(TestData) & HasAttributes(id=1, name="test", value=3.14)

It could be more convenient. But I think whatever the solution is, it should be clear that it doesn't only apply to pydantic or dataclasses.

[15r10nk]

But the problem is that this assertion will not fail when you add an attribute to the model.

This is the part where it becomes special for the used type (that is the to-do above). I have to check all the attributes of the value (pydantic specific code) and check if they are equal to the default value and can be omitted. I will add it tomorrow.

[15r10nk]

But you are right, this is pretty close to the dirty-equals classes you mentioned

[alexmojaki]

What about this, but again not pydantic specific?

class IsPydantic:
    def __init__(self,typ,/,**attributes):
        self.typ=typ
        self.attributes=attributes

    def __eq__(self,other):
        try:
            return self.typ(**self.attributes) == other
        except Exception:
            return False

or even something like:

assert  M(x=1,y=2) == snapshot(lambda: M(x=1, y=2))

[15r10nk]

The first version does not work for dirty equals attributes and the second makes no sense to me. Do you want to compare a pydantic model with a function?

[alexmojaki]

The point of the second is to introduce some laziness to prevent evaluating something broken. It might not be that exact notation, but inline-snapshot would know to treat it specially and not simply use the function value as is.

[alexmojaki]

solution for the todo:

    def __eq__(self, other):
        if type(other) is not self.typ:
            return NotImplemented

        other_attributes = {}
        for name, attribute in self.attributes.items():
            if not hasattr(other, name):
                return False
            other_attr = getattr(other, name)
            if not other_attr == attribute:
                return False
            other_attributes[name] = other_attr

        return self.typ(**other_attributes) == other

[15r10nk]

sorry this does not work:

from pydantic import BaseModel

from inline_snapshot import snapshot

class IsPydantic:
    def __init__(self,typ,/,**attributes):
        self.typ=typ
        self.attributes=attributes

    def __eq__(self, other):
        if type(other) is not self.typ:
            return NotImplemented

        other_attributes = {}
        for name, attribute in self.attributes.items():
            if not hasattr(other, name):
                return False
            other_attr = getattr(other, name)
            if not other_attr == attribute:
                return False
            other_attributes[name] = other_attr

        return self.typ(**other_attributes) == other


class M(BaseModel):
    x:int
    y:int

def test_is_pydantic():

    # old style
    assert M(x=1,y=2) == snapshot(M(x=1,y=2))

    # proposed new style
    assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2))

    # can handle invalid arguments (return False and raise no exception)
    assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2,invalid=5))


    # proposed new style y was not part of the model when this assertion was written
    # but is is now and the snapshot should be fixed
    assert M(x=1,y=5) == snapshot(IsPydantic(M,x=1))

example.py::test_is_pydantic FAILED                                                                [100%]
example.py::test_is_pydantic ERROR                                                                 [100%]

════════════════════════════════════════════ inline-snapshot ═════════════════════════════════════════════
───────────────────────────────────────────── Fix snapshots ──────────────────────────────────────────────
╭────────────────────────────────────────────── example.py ──────────────────────────────────────────────╮
│ @@ -36,7 +36,7 @@                                                                                      │
│                                                                                                        │
│      assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2))                                              │
│                                                                                                        │
│      # can handle invalid arguments (return False and raise no exception)                              │
│ -    assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2,invalid=5))                                    │
│ +    assert M(x=1,y=2) == snapshot(M(x=1,y=2))                                                         │
│                                                                                                        │
│                                                                                                        │
│      # proposed new style y was not part of the model when this assertion was written                  │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Do you want to fix these snapshots? [y/n] (n): n

──────────────────────────────────────────── Update snapshots ────────────────────────────────────────────
╭────────────────────────────────────────────── example.py ──────────────────────────────────────────────╮
│ @@ -33,7 +33,7 @@                                                                                      │
│                                                                                                        │
│      assert M(x=1,y=2) == snapshot(M(x=1,y=2))                                                         │
│                                                                                                        │
│      # proposed new style                                                                              │
│ -    assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2))                                              │
│ +    assert M(x=1,y=2) == snapshot(M(x=1,y=2))                                                         │
│                                                                                                        │
│      # can handle invalid arguments (return False and raise no exception)                              │
│      assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2,invalid=5))                                    │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────╯
Do you want to update these snapshots? [y/n] (n): n



================================================= ERRORS =================================================
_________________________________ ERROR at teardown of test_is_pydantic __________________________________
some snapshots in this test have incorrect values.
If you just created this value with --inline-snapshot=create, the value is now created and you can ignore 
this message.
================================================ FAILURES ================================================
____________________________________________ test_is_pydantic ____________________________________________

    def test_is_pydantic():
    
        # old style
        assert M(x=1,y=2) == snapshot(M(x=1,y=2))
    
        # proposed new style
        assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2))
    
        # can handle invalid arguments (return False and raise no exception)
        assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2,invalid=5))
    
    
        # proposed new style y was not part of the model when this assertion was written
        # but is is now and the snapshot should be fixed
>       assert M(x=1,y=5) == snapshot(IsPydantic(M,x=1))
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

example.py:44: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
src/inline_snapshot/_snapshot/undecided_value.py:161: in __eq__
    return self == other
           ^^^^^^^^^^^^^
src/inline_snapshot/_snapshot/eq_value.py:31: in __eq__
    result = split_gen(
src/inline_snapshot/_generator_utils.py:11: in split_gen
    l.append(next(it))
             ^^^^^^^^
src/inline_snapshot/_new_adapter.py:167: in compare
    result = yield from getattr(self, function_name)(
src/inline_snapshot/_new_adapter.py:394: in compare_CustomCall
    flag = "update" if old_value._eval() == new_value.original_value else "fix"
                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <example.IsPydantic object at 0x7f94b9f42580>, other = M(x=1, y=5)

    def __eq__(self, other):
        if type(other) is not self.typ:
            return NotImplemented
    
        other_attributes = {}
        for name, attribute in self.attributes.items():
            if not hasattr(other, name):
                return False
            other_attr = getattr(other, name)
            if not other_attr == attribute:
                return False
            other_attributes[name] = other_attr
    
>       return self.typ(**other_attributes) == other
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E       pydantic_core._pydantic_core.ValidationError: 1 validation error for M
E       y
E         Field required [type=missing, input_value={'x': 1}, input_type=dict]
E           For further information visit https://errors.pydantic.dev/2.12/v/missing

example.py:23: ValidationError
======================================== short test summary info =========================================
FAILED example.py::test_is_pydantic - pydantic_core._pydantic_core.ValidationError: 1 validation error for
 M
y
  Field required [type=missing, input_value={'x': 1}, input_type=dict]
    For further information visit https://errors.pydantic.dev/2.12/v/missing
ERROR example.py::test_is_pydantic - Failed: some snapshots in this test have incorrect values.
If you just created this value with --inline-snapshot=create, the value is now created and you can ignore 
this message.
======================================= 1 failed, 1 error in 2.58s =======================================

I'm working on it now.

[alexmojaki]

        try:
            return self.typ(**other_attributes) == other
        except Exception:
            return False

[15r10nk]

I have a working solution in #344

but It might look better with:

assert M(x=1,y=2) == snapshot(IsPydantic[M](x=1,y=2))

instead of the current:

assert M(x=1,y=2) == snapshot(IsPydantic(M,x=1,y=2))

syntax

[15r10nk]

try:
return self.typ(**other_attributes) == other
except Exception:
return False

the == comparison would always fail when you use dirty_equal expressions, or?

[alexmojaki]

No, other_attributes is attributes from the real value, just filtered down to those present in self.attributes. It's checking if remaining attributes are required and different from their defaults. There wouldn't be any dirty_equals objects present.

[alexmojaki]

IsPydantic(M)(x=1, y=2) could check types:

from typing import TypeVar, Any
from pydantic import BaseModel

T = TypeVar("T")


class _IsPydantic:
    def __init__(self, typ: type, **attributes: Any) -> None:
        self.typ = typ
        self.attributes = attributes


def IsPydantic(typ: type[T]) -> type[T]:
    # intentional lie about type
    return lambda **kwargs: _IsPydantic(typ, **kwargs)  # type: ignore


class M(BaseModel):
    x: int
    y: int


print(IsPydantic(M)(x=1, y=2))    # passes type checking
print(IsPydantic(M)(x=1, y='a'))  # fails type checking

[15r10nk]

but the type checking work only for "normal types" and not dirty-equals

M(x=IsInt(),y=5)

example.py:34: error: Argument "x" to "M" has incompatible type "IsInt"; expected "int"  [arg-type]

No, other_attributes is attributes from the real value, just filtered down to those present in self.attributes. It's checking if remaining attributes are required and different from their defaults. There wouldn't be any dirty_equals objects present.

yes, you are right. I think this should work in all cases.

But would you prefer a solution like this over the conversion to json from your article? Or are there any other benefits in the conversion?

[alexmojaki]

I think your solution is better because it checks the actual type and doesn't require a conversion function. But I can imagine it confusing new users.