add default comparison

Author: andresliszt

python/pydantic_core/core_schema.py

@@ -2186,6 +2186,7 @@ def with_default_schema(
     *,
     default: Any = PydanticUndefined,
     default_factory: Callable[[], Any] | None = None,
+    default_comparison: Callable[[Any, Any], bool] | None = None,
     on_error: Literal['raise', 'omit', 'default'] | None = None,
     validate_default: bool | None = None,
     strict: bool | None = None,
@@ -2211,6 +2212,7 @@ def with_default_schema(
         schema: The schema to add a default value to
         default: The default value to use
         default_factory: A function that returns the default value to use
+        default_factory: A function to compare the default value with any other given
         on_error: What to do if the schema validation fails. One of 'raise', 'omit', 'default'
         validate_default: Whether the default value should be validated
         strict: Whether the underlying schema should be validated with strict mode
@@ -2222,6 +2224,7 @@ def with_default_schema(
         type='default',
         schema=schema,
         default_factory=default_factory,
+        default_comparison=default_comparison,
         on_error=on_error,
         validate_default=validate_default,
         strict=strict,

src/serializers/fields.rs

@@ -68,12 +68,9 @@ impl SerField {
 }
 
 fn exclude_default(value: &PyAny, extra: &Extra, serializer: &CombinedSerializer) -> PyResult<bool> {
+    let py = value.py();
     if extra.exclude_defaults {
-        if let Some(default) = serializer.get_default(value.py())? {
-            if value.eq(default)? {
-                return Ok(true);
-            }
-        }
+        return serializer.compare_with_default(py, value);
     }
     Ok(false)
 }

src/serializers/shared.rs

@@ -301,6 +301,10 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
     fn get_default(&self, _py: Python) -> PyResult<Option<PyObject>> {
         Ok(None)
     }
+
+    fn compare_with_default(&self, _py: Python, _value: &PyAny) -> PyResult<bool> {
+        Ok(false)
+    }
 }
 
 pub(crate) struct PydanticSerializer<'py> {

src/serializers/type_serializers/with_default.rs

@@ -13,6 +13,7 @@ use super::{BuildSerializer, CombinedSerializer, Extra, TypeSerializer};
 #[derive(Debug, Clone)]
 pub struct WithDefaultSerializer {
     default: DefaultType,
+    default_comparison: Option<PyObject>,
     serializer: Box<CombinedSerializer>,
 }
 
@@ -26,11 +27,16 @@ impl BuildSerializer for WithDefaultSerializer {
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let default = DefaultType::new(schema)?;
-
+        let default_comparison = schema.get_as(intern!(py, "default_comparison"))?;
         let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
         let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
 
-        Ok(Self { default, serializer }.into())
+        Ok(Self {
+            default,
+            default_comparison,
+            serializer,
+        }
+        .into())
     }
 }
 
@@ -74,4 +80,16 @@ impl TypeSerializer for WithDefaultSerializer {
     fn get_default(&self, py: Python) -> PyResult<Option<PyObject>> {
         self.default.default_value(py)
     }
+
+    fn compare_with_default(&self, py: Python, value: &PyAny) -> PyResult<bool> {
+        if let Some(default) = self.get_default(py)? {
+            if let Some(default_comparison) = &self.default_comparison {
+                return default_comparison.call(py, (value, default), None)?.extract::<bool>(py);
+            } else if value.eq(default)? {
+                return Ok(true);
+            }
+        }
+
+        Ok(false)
+    }
 }

tests/serializers/test_typed_dict.py

@@ -150,24 +150,47 @@ def test_exclude_none():
 
 
 def test_exclude_default():
+    class TestComparison:
+        def __init__(self, val: Any):
+            self.val = val
+
+        def __eq__(self, other):
+            return self.val == other.val
+
     v = SchemaSerializer(
         core_schema.typed_dict_schema(
             {
                 'foo': core_schema.typed_dict_field(core_schema.nullable_schema(core_schema.int_schema())),
                 'bar': core_schema.typed_dict_field(
                     core_schema.with_default_schema(core_schema.bytes_schema(), default=b'[default]')
                 ),
+                'foobar': core_schema.typed_dict_field(
+                    core_schema.with_default_schema(
+                        core_schema.any_schema(),
+                        default=TestComparison(val=1),
+                        default_comparison=lambda value, default: value.val == -1 * default.val,
+                    )
+                ),
             }
         )
     )
     assert v.to_python({'foo': 1, 'bar': b'x'}) == {'foo': 1, 'bar': b'x'}
     assert v.to_python({'foo': 1, 'bar': b'[default]'}) == {'foo': 1, 'bar': b'[default]'}
     assert v.to_python({'foo': 1, 'bar': b'[default]'}, exclude_defaults=True) == {'foo': 1}
     assert v.to_python({'foo': 1, 'bar': b'[default]'}, mode='json') == {'foo': 1, 'bar': '[default]'}
-    assert v.to_python({'foo': 1, 'bar': b'[default]'}, exclude_defaults=True, mode='json') == {'foo': 1}
-
     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}'
+    # Note that due to the custom comparison operator foobar must be excluded
+    assert v.to_python({'foo': 1, 'bar': b'x', 'foobar': TestComparison(val=-1)}, exclude_defaults=True) == {
+        'foo': 1,
+        'bar': b'x',
+    }
+    # foobar here must be included
+    assert v.to_python({'foo': 1, 'bar': b'x', 'foobar': TestComparison(val=1)}, exclude_defaults=True) == {
+        'foo': 1,
+        'bar': b'x',
+        'foobar': TestComparison(val=1),
+    }
 
 
 def test_function_plain_field_serializer_to_python():