Fix type of self argument for model serializer's to_json method (#461)

Author: adriangb

src/serializers/type_serializers/model.rs

@@ -98,13 +98,17 @@ impl TypeSerializer for ModelSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        if self.allow_value(value, extra).map_err(py_err_se_err)? {
-            let dict = object_to_dict(value, true, extra).map_err(py_err_se_err)?;
+        let extra = Extra {
+            model: Some(value),
+            ..*extra
+        };
+        if self.allow_value(value, &extra).map_err(py_err_se_err)? {
+            let dict = object_to_dict(value, true, &extra).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(dict, serializer, include, exclude, extra)
+                .serde_serialize(dict, serializer, include, exclude, &extra)
         } else {
-            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
-            infer_serialize(value, serializer, include, exclude, extra)
+            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, &extra)?;
+            infer_serialize(value, serializer, include, exclude, &extra)
         }
     }
 

tests/serializers/test_model.py

@@ -403,6 +403,7 @@ class Model:
         x: int
 
         def ser_x(self, v: Any, _) -> str:
+            assert self.x == 1_000
             return f'{v:_}'
 
     s = SchemaSerializer(
@@ -427,6 +428,7 @@ class Model:
 
         def ser_x(self, v: Any, serializer: core_schema.SerializeWrapHandler, _) -> str:
             x = serializer(v)
+            assert self.x == 1_000
             return f'{x:_}'
 
     s = SchemaSerializer(
@@ -454,6 +456,7 @@ class Model:
         x: int
 
         def ser_x(self, v: Any, _) -> str:
+            assert self.x == 1_000
             return f'{v:_}'
 
     s = SchemaSerializer(
@@ -477,6 +480,7 @@ class Model:
         x: int
 
         def ser_x(self, v: Any, serializer: core_schema.SerializeWrapHandler, _) -> str:
+            assert self.x == 1_000
             x = serializer(v)
             return f'{x:_}'
 

tests/serializers/test_typed_dict.py

@@ -1,7 +1,9 @@
 import json
+from typing import Any
 
 import pytest
 from dirty_equals import IsStrictDict
+from typing_extensions import TypedDict
 
 from pydantic_core import SchemaSerializer, core_schema
 
@@ -159,3 +161,89 @@ def test_exclude_default():
 
     assert v.to_json({'foo': 1, 'bar': b'[default]'}) == b'{"foo":1,"bar":"[default]"}'
     assert v.to_json({'foo': 1, 'bar': b'[default]'}, exclude_defaults=True) == b'{"foo":1}'
+
+
+def test_function_plain_field_serializer_to_python():
+    class Model(TypedDict):
+        x: int
+
+    def ser_x(data: Model, v: Any, _) -> str:
+        assert data['x'] == 1_000
+        return f'{v:_}'
+
+    s = SchemaSerializer(
+        core_schema.typed_dict_schema(
+            {
+                'x': core_schema.typed_dict_field(
+                    core_schema.int_schema(serialization=core_schema.field_function_plain_ser_schema(ser_x))
+                )
+            }
+        )
+    )
+    assert s.to_python(Model(x=1000)) == {'x': '1_000'}
+
+
+def test_function_wrap_field_serializer_to_python():
+    class Model(TypedDict):
+        x: int
+
+    def ser_x(data: Model, v: Any, serializer: core_schema.SerializeWrapHandler, _) -> str:
+        x = serializer(v)
+        assert data['x'] == 1_000
+        return f'{x:_}'
+
+    s = SchemaSerializer(
+        core_schema.typed_dict_schema(
+            {
+                'x': core_schema.typed_dict_field(
+                    core_schema.int_schema(
+                        serialization=core_schema.field_function_wrap_ser_schema(ser_x, schema=core_schema.any_schema())
+                    )
+                )
+            }
+        )
+    )
+    assert s.to_python(Model(x=1000)) == {'x': '1_000'}
+
+
+def test_function_plain_field_serializer_to_json():
+    class Model(TypedDict):
+        x: int
+
+    def ser_x(data: Model, v: Any, _) -> str:
+        assert data['x'] == 1_000
+        return f'{v:_}'
+
+    s = SchemaSerializer(
+        core_schema.typed_dict_schema(
+            {
+                'x': core_schema.typed_dict_field(
+                    core_schema.int_schema(serialization=core_schema.field_function_plain_ser_schema(ser_x))
+                )
+            }
+        )
+    )
+    assert json.loads(s.to_json(Model(x=1000))) == {'x': '1_000'}
+
+
+def test_function_wrap_field_serializer_to_json():
+    class Model(TypedDict):
+        x: int
+
+    def ser_x(data: Model, v: Any, serializer: core_schema.SerializeWrapHandler, _) -> str:
+        assert data['x'] == 1_000
+        x = serializer(v)
+        return f'{x:_}'
+
+    s = SchemaSerializer(
+        core_schema.typed_dict_schema(
+            {
+                'x': core_schema.typed_dict_field(
+                    core_schema.int_schema(
+                        serialization=core_schema.field_function_wrap_ser_schema(ser_x, schema=core_schema.any_schema())
+                    )
+                )
+            }
+        )
+    )
+    assert json.loads(s.to_json(Model(x=1000))) == {'x': '1_000'}