rename exclude_if by serialization_exclude_if

Author: andresliszt

python/pydantic_core/core_schema.py

@@ -2980,7 +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,
+    serialization_exclude_if: Callable[[Any], bool] | None = None,
     frozen: bool | None = None,
     metadata: dict[str, Any] | None = None,
 ) -> ModelField:
@@ -2998,7 +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.
+        serialization_exclude_if: A 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
     """
@@ -3008,7 +3008,7 @@ def model_field(
         validation_alias=validation_alias,
         serialization_alias=serialization_alias,
         serialization_exclude=serialization_exclude,
-        exclude_if=exclude_if,
+        serialization_exclude_if=serialization_exclude_if,
         frozen=frozen,
         metadata=metadata,
     )

src/serializers/fields.rs

@@ -29,7 +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>>,
+    pub serialization_exclude_if: Option<Py<PyAny>>,
 }
 
 impl_py_gc_traverse!(SerField { serializer });
@@ -42,7 +42,7 @@ impl SerField {
         serializer: Option<CombinedSerializer>,
         required: bool,
         serialize_by_alias: Option<bool>,
-        exclude_if: Option<Py<PyAny>>,
+        serialization_exclude_if: Option<Py<PyAny>>,
     ) -> Self {
         let alias_py = alias.as_ref().map(|alias| PyString::new(py, alias.as_str()).into());
         Self {
@@ -52,7 +52,7 @@ impl SerField {
             serializer,
             required,
             serialize_by_alias,
-            exclude_if,
+            serialization_exclude_if,
         }
     }
 
@@ -75,7 +75,7 @@ impl SerField {
     }
 }
 
-fn exclude_if(exclude_if_callable: &Option<Py<PyAny>>, value: &Bound<'_, PyAny>) -> PyResult<bool> {
+fn serialization_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,))?;
@@ -194,7 +194,7 @@ impl GeneralFieldsSerializer {
                         if exclude_default(&value, &field_extra, serializer)? {
                             continue;
                         }
-                        if exclude_if(&field.exclude_if, &value)? {
+                        if serialization_exclude_if(&field.serialization_exclude_if, &value)? {
                             continue;
                         }
                         let value =
@@ -275,7 +275,7 @@ impl GeneralFieldsSerializer {
                         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)? {
+                        if serialization_exclude_if(&field.serialization_exclude_if, &value).map_err(py_err_se_err)? {
                             continue;
                         }
                         let s = PydanticSerializer::new(

src/serializers/type_serializers/dataclass.rs

@@ -46,25 +46,35 @@ impl BuildSerializer for DataclassArgsBuilder {
             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, None));
+                    fields.insert(
+                        name,
+                        SerField::new(py, key_py, None, None, true, serialize_by_alias, 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"))?;
+                    let serialization_exclude_if: Option<Py<PyAny>> = field_info.get_as(intern!(py, "serialization_exclude_if"))?;
                     fields.insert(
                         name,
-                        SerField::new(py, key_py, alias, Some(serializer), true, exclude_if),
+                        SerField::new(
+                            py,
+                            key_py,
+                            alias,
+                            Some(serializer),
+                            true,
+                            serialize_by_alias,
+                            serialization_exclude_if,
+                        ),
                     );
                 }
-            };
-
-            let computed_fields = ComputedFields::new(schema, config, definitions)?;
-
-            Ok(GeneralFieldsSerializer::new(fields, fields_mode, None, computed_fields).into())
+            }
         }
+        let computed_fields = ComputedFields::new(schema, config, definitions)?;
+
+        Ok(GeneralFieldsSerializer::new(fields, fields_mode, None, computed_fields).into())
     }
 }
 

src/serializers/type_serializers/model.rs

@@ -63,7 +63,7 @@ impl BuildSerializer for ModelFieldsBuilder {
                 );
             } 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 serialization_exclude_if: Option<Py<PyAny>> = field_info.get_as(intern!(py, "serialization_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))?;
@@ -77,7 +77,7 @@ impl BuildSerializer for ModelFieldsBuilder {
                         Some(serializer),
                         true,
                         serialize_by_alias,
-                        exclude_if,
+                        serialization_exclude_if,
                     ),
                 );
             }

src/serializers/type_serializers/typed_dict.rs

@@ -60,7 +60,7 @@ impl BuildSerializer for TypedDictBuilder {
                 );
             } 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 serialization_exclude_if: Option<Py<PyAny>> = field_info.get_as(intern!(py, "serialization_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))?;
@@ -73,7 +73,7 @@ impl BuildSerializer for TypedDictBuilder {
                         Some(serializer),
                         required,
                         serialize_by_alias,
-                        exclude_if,
+                        serialization_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(), exclude_if=lambda x: x == 'bye'),
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema(), serialization_exclude_if=lambda x: x == 'bye'),
                 core_schema.dataclass_field(name='b', schema=core_schema.bytes_schema(), serialization_exclude=True),
             ],
         ),

tests/serializers/test_functions.py

@@ -518,7 +518,7 @@ def __init__(self, **kwargs):
             core_schema.typed_dict_schema(
                 {
                     'a': core_schema.typed_dict_field(
-                        core_schema.any_schema(), exclude_if=lambda x: isinstance(x, int) and x >= 2
+                        core_schema.any_schema(), serialization_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),
@@ -569,7 +569,7 @@ def __init__(self, **kwargs):
             MyModel,
             core_schema.typed_dict_schema(
                 {
-                    'a': core_schema.typed_dict_field(core_schema.any_schema(), exclude_if=lambda x: x == 100),
+                    'a': core_schema.typed_dict_field(core_schema.any_schema(), serialization_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

@@ -209,10 +209,10 @@ def test_exclude_if():
             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),
+                    'a': core_schema.model_field(core_schema.int_schema(), serialization_exclude_if=lambda x: x > 1),
+                    'b': core_schema.model_field(core_schema.str_schema(), serialization_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
+                        core_schema.str_schema(), serialization_exclude=True, serialization_exclude_if=lambda x: 'foo' in x
                     ),
                 }
             ),

tests/serializers/test_typed_dict.py

@@ -93,10 +93,10 @@ def test_include_exclude_schema():
                 '0': core_schema.typed_dict_field(core_schema.int_schema(), serialization_exclude=True),
                 '1': core_schema.typed_dict_field(core_schema.int_schema()),
                 '2': core_schema.typed_dict_field(
-                    core_schema.int_schema(), serialization_exclude=True, exclude_if=lambda x: x < 0
+                    core_schema.int_schema(), serialization_exclude=True, serialization_exclude_if=lambda x: x < 0
                 ),
                 '3': core_schema.typed_dict_field(
-                    core_schema.int_schema(), serialization_exclude=False, exclude_if=lambda x: x < 0
+                    core_schema.int_schema(), serialization_exclude=False, serialization_exclude_if=lambda x: x < 0
                 ),
             }
         )