Support exclude_if callable at field level

Author: andresliszt

python/pydantic_core/core_schema.py

@@ -2839,6 +2839,7 @@ class TypedDictField(TypedDict, total=False):
     serialization_alias: str
     serialization_exclude: bool  # default: False
     metadata: dict[str, Any]
+    serialization_exclude_if: Callable[[Any], bool]  # default None
 
 
 def typed_dict_field(
@@ -2849,6 +2850,7 @@ def typed_dict_field(
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
     metadata: dict[str, Any] | None = None,
+    serialization_exclude_if: Callable[[Any], bool] | None = None,
 ) -> TypedDictField:
     """
     Returns a schema that matches a typed dict field, e.g.:
@@ -2865,6 +2867,7 @@ def typed_dict_field(
         validation_alias: The alias(es) to use to find the field in the validation data
         serialization_alias: The alias to use as a key when serializing
         serialization_exclude: Whether to exclude the field when serializing
+        serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value.
         metadata: Any other information you want to include with the schema, not used by pydantic-core
     """
     return _dict_not_none(
@@ -2874,6 +2877,7 @@ def typed_dict_field(
         validation_alias=validation_alias,
         serialization_alias=serialization_alias,
         serialization_exclude=serialization_exclude,
+        serialization_exclude_if=serialization_exclude_if,
         metadata=metadata,
     )
 
@@ -2965,6 +2969,7 @@ class ModelField(TypedDict, total=False):
     validation_alias: Union[str, list[Union[str, int]], list[list[Union[str, int]]]]
     serialization_alias: str
     serialization_exclude: bool  # default: False
+    serialization_exclude_if: Callable[[Any], bool]  # default: None
     frozen: bool
     metadata: dict[str, Any]
 
@@ -2975,6 +2980,7 @@ def model_field(
     validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
+    exclude_if: Callable[[Any], bool] | None = None,
     frozen: bool | None = None,
     metadata: dict[str, Any] | None = None,
 ) -> ModelField:
@@ -2992,6 +2998,7 @@ def model_field(
         validation_alias: The alias(es) to use to find the field in the validation data
         serialization_alias: The alias to use as a key when serializing
         serialization_exclude: Whether to exclude the field when serializing
+        exclude_if: Callable that determines whether to exclude a field during serialization based on its value.
         frozen: Whether the field is frozen
         metadata: Any other information you want to include with the schema, not used by pydantic-core
     """
@@ -3001,6 +3008,7 @@ def model_field(
         validation_alias=validation_alias,
         serialization_alias=serialization_alias,
         serialization_exclude=serialization_exclude,
+        exclude_if=exclude_if,
         frozen=frozen,
         metadata=metadata,
     )
@@ -3193,6 +3201,7 @@ class DataclassField(TypedDict, total=False):
     serialization_alias: str
     serialization_exclude: bool  # default: False
     metadata: dict[str, Any]
+    serialization_exclude_if: Callable[[Any], bool]  # default: None
 
 
 def dataclass_field(
@@ -3206,6 +3215,7 @@ def dataclass_field(
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
     metadata: dict[str, Any] | None = None,
+    serialization_exclude_if: Callable[[Any], bool] | None = None,
     frozen: bool | None = None,
 ) -> DataclassField:
     """
@@ -3231,6 +3241,7 @@ def dataclass_field(
         validation_alias: The alias(es) to use to find the field in the validation data
         serialization_alias: The alias to use as a key when serializing
         serialization_exclude: Whether to exclude the field when serializing
+        serialization_exclude_if: A callable that determines whether to exclude the field when serializing based on its value.
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         frozen: Whether the field is frozen
     """
@@ -3244,6 +3255,7 @@ def dataclass_field(
         validation_alias=validation_alias,
         serialization_alias=serialization_alias,
         serialization_exclude=serialization_exclude,
+        serialization_exclude_if=serialization_exclude_if,
         metadata=metadata,
         frozen=frozen,
     )

src/serializers/fields.rs

@@ -29,6 +29,7 @@ pub(super) struct SerField {
     pub serializer: Option<CombinedSerializer>,
     pub required: bool,
     pub serialize_by_alias: Option<bool>,
+    pub exclude_if: Option<Py<PyAny>>,
 }
 
 impl_py_gc_traverse!(SerField { serializer });
@@ -41,6 +42,7 @@ impl SerField {
         serializer: Option<CombinedSerializer>,
         required: bool,
         serialize_by_alias: Option<bool>,
+        exclude_if: Option<Py<PyAny>>,
     ) -> Self {
         let alias_py = alias.as_ref().map(|alias| PyString::new(py, alias.as_str()).into());
         Self {
@@ -50,6 +52,7 @@ impl SerField {
             serializer,
             required,
             serialize_by_alias,
+            exclude_if,
         }
     }
 
@@ -72,6 +75,18 @@ impl SerField {
     }
 }
 
+fn exclude_if(exclude_if_callable: &Option<Py<PyAny>>, value: &Bound<'_, PyAny>) -> PyResult<bool> {
+    if let Some(exclude_if_callable) = exclude_if_callable {
+        let py = value.py();
+        let result = exclude_if_callable.call1(py, (value,))?;
+        let exclude = result.extract::<bool>(py)?;
+        if exclude {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
 fn exclude_default(value: &Bound<'_, PyAny>, extra: &Extra, serializer: &CombinedSerializer) -> PyResult<bool> {
     if extra.exclude_defaults {
         if let Some(default) = serializer.get_default(value.py())? {
@@ -176,16 +191,16 @@ impl GeneralFieldsSerializer {
             if let Some((next_include, next_exclude)) = self.filter.key_filter(&key, include, exclude)? {
                 if let Some(field) = op_field {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(&value, &field_extra, serializer)? {
-                            let value = serializer.to_python(
-                                &value,
-                                next_include.as_ref(),
-                                next_exclude.as_ref(),
-                                &field_extra,
-                            )?;
-                            let output_key = field.get_key_py(output_dict.py(), &field_extra);
-                            output_dict.set_item(output_key, value)?;
+                        if exclude_default(&value, &field_extra, serializer)? {
+                            continue;
                         }
+                        if exclude_if(&field.exclude_if, &value)? {
+                            continue;
+                        }
+                        let value =
+                            serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?;
+                        let output_key = field.get_key_py(output_dict.py(), &field_extra);
+                        output_dict.set_item(output_key, value)?;
                     }
 
                     if field.required {
@@ -257,17 +272,21 @@ impl GeneralFieldsSerializer {
             if let Some((next_include, next_exclude)) = filter {
                 if let Some(field) = self.fields.get(key_str) {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(&value, &field_extra, serializer).map_err(py_err_se_err)? {
-                            let s = PydanticSerializer::new(
-                                &value,
-                                serializer,
-                                next_include.as_ref(),
-                                next_exclude.as_ref(),
-                                &field_extra,
-                            );
-                            let output_key = field.get_key_json(key_str, &field_extra);
-                            map.serialize_entry(&output_key, &s)?;
+                        if exclude_default(&value, &field_extra, serializer).map_err(py_err_se_err)? {
+                            continue;
+                        }
+                        if exclude_if(&field.exclude_if, &value).map_err(py_err_se_err)? {
+                            continue;
                         }
+                        let s = PydanticSerializer::new(
+                            &value,
+                            serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            &field_extra,
+                        );
+                        let output_key = field.get_key_json(key_str, &field_extra);
+                        map.serialize_entry(&output_key, &s)?;
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
                     let output_key = infer_json_key(&key, &field_extra).map_err(py_err_se_err)?;

src/serializers/type_serializers/dataclass.rs

@@ -44,27 +44,27 @@ impl BuildSerializer for DataclassArgsBuilder {
             let name: String = field_info.get_as_req(intern!(py, "name"))?;
 
             let key_py: Py<PyString> = PyString::new(py, &name).into();
-
             if !field_info.get_as(intern!(py, "init_only"))?.unwrap_or(false) {
                 if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                    fields.insert(name, SerField::new(py, key_py, None, None, true, serialize_by_alias));
+                    fields.insert(name, SerField::new(py, key_py, None, None, true, None));
                 } else {
                     let schema = field_info.get_as_req(intern!(py, "schema"))?;
                     let serializer = CombinedSerializer::build(&schema, config, definitions)
                         .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", index, e))?;
 
                     let alias = field_info.get_as(intern!(py, "serialization_alias"))?;
+                    let exclude_if: Option<Py<PyAny>> = field_info.get_as(intern!(py, "exclude_if"))?;
                     fields.insert(
                         name,
-                        SerField::new(py, key_py, alias, Some(serializer), true, serialize_by_alias),
+                        SerField::new(py, key_py, alias, Some(serializer), true, exclude_if),
                     );
                 }
-            }
-        }
+            };
 
-        let computed_fields = ComputedFields::new(schema, config, definitions)?;
+            let computed_fields = ComputedFields::new(schema, config, definitions)?;
 
-        Ok(GeneralFieldsSerializer::new(fields, fields_mode, None, computed_fields).into())
+            Ok(GeneralFieldsSerializer::new(fields, fields_mode, None, computed_fields).into())
+        }
     }
 }
 

src/serializers/type_serializers/model.rs

@@ -57,17 +57,28 @@ impl BuildSerializer for ModelFieldsBuilder {
             let key_py: Py<PyString> = key_py.into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                fields.insert(key, SerField::new(py, key_py, None, None, true, serialize_by_alias));
+                fields.insert(
+                    key,
+                    SerField::new(py, key_py, None, None, true, serialize_by_alias, None),
+                );
             } else {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
-
+                let exclude_if: Option<Py<PyAny>> = field_info.get_as(intern!(py, "exclude_if"))?;
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
                 let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
 
                 fields.insert(
                     key,
-                    SerField::new(py, key_py, alias, Some(serializer), true, serialize_by_alias),
+                    SerField::new(
+                        py,
+                        key_py,
+                        alias,
+                        Some(serializer),
+                        true,
+                        serialize_by_alias,
+                        exclude_if,
+                    ),
                 );
             }
         }

src/serializers/type_serializers/typed_dict.rs

@@ -54,16 +54,27 @@ impl BuildSerializer for TypedDictBuilder {
             let required = field_info.get_as(intern!(py, "required"))?.unwrap_or(total);
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                fields.insert(key, SerField::new(py, key_py, None, None, required, serialize_by_alias));
+                fields.insert(
+                    key,
+                    SerField::new(py, key_py, None, None, required, serialize_by_alias, None),
+                );
             } else {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
-
+                let exclude_if: Option<Py<PyAny>> = field_info.get_as(intern!(py, "exclude_if"))?;
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
                 let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
                 fields.insert(
                     key,
-                    SerField::new(py, key_py, alias, Some(serializer), required, serialize_by_alias),
+                    SerField::new(
+                        py,
+                        key_py,
+                        alias,
+                        Some(serializer),
+                        required,
+                        serialize_by_alias,
+                        exclude_if,
+                    ),
                 );
             }
         }

tests/serializers/test_dataclasses.py

@@ -54,7 +54,7 @@ def test_serialization_exclude():
         core_schema.dataclass_args_schema(
             'Foo',
             [
-                core_schema.dataclass_field(name='a', schema=core_schema.str_schema()),
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema(), exclude_if=lambda x: x == 'bye'),
                 core_schema.dataclass_field(name='b', schema=core_schema.bytes_schema(), serialization_exclude=True),
             ],
         ),
@@ -63,12 +63,18 @@ def test_serialization_exclude():
     s = SchemaSerializer(schema)
     assert s.to_python(Foo(a='hello', b=b'more')) == {'a': 'hello'}
     assert s.to_python(Foo(a='hello', b=b'more'), mode='json') == {'a': 'hello'}
+    # a = 'bye' excludes it
+    assert s.to_python(Foo(a='bye', b=b'more'), mode='json') == {}
     j = s.to_json(Foo(a='hello', b=b'more'))
-
     if on_pypy:
         assert json.loads(j) == {'a': 'hello'}
     else:
         assert j == b'{"a":"hello"}'
+    j = s.to_json(Foo(a='bye', b=b'more'))
+    if on_pypy:
+        assert json.loads(j) == {}
+    else:
+        assert j == b'{}'
 
 
 def test_serialization_alias():

tests/serializers/test_functions.py

@@ -517,7 +517,9 @@ def __init__(self, **kwargs):
             MyModel,
             core_schema.typed_dict_schema(
                 {
-                    'a': core_schema.typed_dict_field(core_schema.any_schema()),
+                    'a': core_schema.typed_dict_field(
+                        core_schema.any_schema(), exclude_if=lambda x: isinstance(x, int) and x >= 2
+                    ),
                     'b': core_schema.typed_dict_field(core_schema.any_schema()),
                     'c': core_schema.typed_dict_field(core_schema.any_schema(), serialization_exclude=True),
                 }
@@ -541,6 +543,14 @@ def __init__(self, **kwargs):
     assert s.to_json(m, exclude={'b'}) == b'{"a":1}'
     assert calls == 6
 
+    m = MyModel(a=2, b=b'foobar', c='excluded')
+    assert s.to_python(m) == {'b': b'foobar'}
+    assert calls == 7
+    assert s.to_python(m, mode='json') == {'b': 'foobar'}
+    assert calls == 8
+    assert s.to_json(m) == b'{"b":"foobar"}'
+    assert calls == 9
+
 
 def test_function_plain_model():
     calls = 0
@@ -559,7 +569,7 @@ def __init__(self, **kwargs):
             MyModel,
             core_schema.typed_dict_schema(
                 {
-                    'a': core_schema.typed_dict_field(core_schema.any_schema()),
+                    'a': core_schema.typed_dict_field(core_schema.any_schema(), exclude_if=lambda x: x == 100),
                     'b': core_schema.typed_dict_field(core_schema.any_schema()),
                     'c': core_schema.typed_dict_field(core_schema.any_schema(), serialization_exclude=True),
                 }

tests/serializers/test_model.py

@@ -203,6 +203,32 @@ def test_include_exclude_args(params):
     assert json.loads(s.to_json(value, include=include, exclude=exclude)) == expected
 
 
+def test_exclude_if():
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            BasicModel,
+            core_schema.model_fields_schema(
+                {
+                    'a': core_schema.model_field(core_schema.int_schema(), exclude_if=lambda x: x > 1),
+                    'b': core_schema.model_field(core_schema.str_schema(), exclude_if=lambda x: 'foo' in x),
+                    'c': core_schema.model_field(
+                        core_schema.str_schema(), serialization_exclude=True, exclude_if=lambda x: 'foo' in x
+                    ),
+                }
+            ),
+        )
+    )
+    assert s.to_python(BasicModel(a=0, b='bar', c='bar')) == {'a': 0, 'b': 'bar'}
+    assert s.to_python(BasicModel(a=2, b='bar', c='bar')) == {'b': 'bar'}
+    assert s.to_python(BasicModel(a=0, b='foo', c='bar')) == {'a': 0}
+    assert s.to_python(BasicModel(a=2, b='foo', c='bar')) == {}
+
+    assert s.to_json(BasicModel(a=0, b='bar', c='bar')) == b'{"a":0,"b":"bar"}'
+    assert s.to_json(BasicModel(a=2, b='bar', c='bar')) == b'{"b":"bar"}'
+    assert s.to_json(BasicModel(a=0, b='foo', c='bar')) == b'{"a":0}'
+    assert s.to_json(BasicModel(a=2, b='foo', c='bar')) == b'{}'
+
+
 def test_alias():
     s = SchemaSerializer(
         core_schema.model_schema(