move include / exclude into SerializationState (#1859)

Author: davidhewitt

src/errors/validation_exception.rs

@@ -339,7 +339,7 @@ impl ValidationError {
         include_input: bool,
     ) -> PyResult<Bound<'py, PyString>> {
         let config = SerializationConfig::from_args("iso8601", "iso8601", "utf8", "constants")?;
-        let mut state = SerializationState::new(config, WarningsMode::None)?;
+        let mut state = SerializationState::new(config, WarningsMode::None, None, None)?;
         let extra = Extra::new(
             py,
             &SerMode::Json,

src/serializers/computed_fields.rs

@@ -43,102 +43,72 @@ impl ComputedFields {
         self.0.len()
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn to_python<'py>(
         &self,
         model: &Bound<'py, PyAny>,
         output_dict: &Bound<'py, PyDict>,
         filter: &SchemaFilter<isize>,
-        include: Option<&Bound<'py, PyAny>>,
-        exclude: Option<&Bound<'py, PyAny>>,
         state: &mut SerializationState<'py>,
         extra: &Extra<'_, 'py>,
     ) -> PyResult<()> {
         self.serialize_fields(
             model,
             filter,
-            include,
-            exclude,
             state,
             extra,
             |e| e,
             |ComputedFieldToSerialize {
                  computed_field,
                  value,
-                 include,
-                 exclude,
                  state,
                  field_extra,
              }| {
                 let key = match field_extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
                     true => computed_field.alias_py.bind(model.py()),
                     false => computed_field.property_name_py.bind(model.py()),
                 };
-                let value = computed_field.serializer.to_python(
-                    &value,
-                    include.as_ref(),
-                    exclude.as_ref(),
-                    state,
-                    field_extra,
-                )?;
+                let value = computed_field.serializer.to_python(&value, state, field_extra)?;
                 output_dict.set_item(key, value)
             },
         )
     }
 
-    #[allow(clippy::too_many_arguments)]
     pub fn serde_serialize<'py, S: serde::ser::Serializer>(
         &self,
         model: &Bound<'py, PyAny>,
         map: &mut S::SerializeMap,
         filter: &SchemaFilter<isize>,
-        include: Option<&Bound<'py, PyAny>>,
-        exclude: Option<&Bound<'py, PyAny>>,
         state: &mut SerializationState<'py>,
         extra: &Extra<'_, 'py>,
     ) -> Result<(), S::Error> {
         self.serialize_fields(
             model,
             filter,
-            include,
-            exclude,
             state,
             extra,
             py_err_se_err,
             |ComputedFieldToSerialize {
                  computed_field,
                  value,
-                 include,
-                 exclude,
                  state,
                  field_extra,
              }| {
                 let key = match field_extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
                     true => &computed_field.alias,
                     false => &computed_field.property_name,
                 };
-                let s = PydanticSerializer::new(
-                    &value,
-                    &computed_field.serializer,
-                    include.as_ref(),
-                    exclude.as_ref(),
-                    state,
-                    field_extra,
-                );
+                let s = PydanticSerializer::new(&value, &computed_field.serializer, state, field_extra);
                 map.serialize_entry(key, &s)
             },
         )
     }
 
     /// Iterate each field for serialization, filtering on
     /// `include` and `exclude` if provided.
-    #[allow(clippy::too_many_arguments)]
     fn serialize_fields<'a, 'py, E>(
         &'a self,
         model: &'a Bound<'py, PyAny>,
         filter: &'a SchemaFilter<isize>,
-        include: Option<&'a Bound<'py, PyAny>>,
-        exclude: Option<&'a Bound<'py, PyAny>>,
         state: &mut SerializationState<'py>,
         extra: &'a Extra<'_, 'py>,
         convert_error: impl FnOnce(PyErr) -> E,
@@ -151,7 +121,7 @@ impl ComputedFields {
 
         for computed_field in &self.0 {
             let property_name_py = computed_field.property_name_py.bind(model.py());
-            let (next_include, next_exclude) = match filter.key_filter(property_name_py, include, exclude) {
+            let (next_include, next_exclude) = match filter.key_filter(property_name_py, state) {
                 Ok(Some((next_include, next_exclude))) => (next_include, next_exclude),
                 Ok(None) => continue,
                 Err(e) => return Err(convert_error(e)),
@@ -173,11 +143,10 @@ impl ComputedFields {
 
             let field_name = FieldName::from(computed_field.property_name_py.bind(model.py()).clone());
             let state = &mut state.scoped_set(|s| &mut s.field_name, Some(field_name));
+            let state = &mut state.scoped_include_exclude(next_include, next_exclude);
             serialize(ComputedFieldToSerialize {
                 computed_field,
                 value,
-                include: next_include,
-                exclude: next_exclude,
                 state,
                 field_extra: extra,
             })?;
@@ -189,8 +158,6 @@ impl ComputedFields {
 struct ComputedFieldToSerialize<'a, 'slf, 'py> {
     computed_field: &'a ComputedField,
     value: Bound<'py, PyAny>,
-    include: Option<Bound<'py, PyAny>>,
-    exclude: Option<Bound<'py, PyAny>>,
     state: &'slf mut SerializationState<'py>,
     field_extra: &'slf Extra<'a, 'py>,
 }

src/serializers/extra.rs

@@ -27,6 +27,7 @@ pub(crate) struct SerializationState<'py> {
     pub rec_guard: RecursionState,
     pub config: SerializationConfig,
     pub field_name: Option<FieldName<'py>>,
+    pub include_exclude: (Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>),
 }
 
 #[derive(Clone)]
@@ -50,18 +51,26 @@ impl fmt::Display for FieldName<'_> {
     }
 }
 
-impl SerializationState<'_> {
-    pub fn new(config: SerializationConfig, warnings_mode: WarningsMode) -> PyResult<Self> {
+impl<'py> SerializationState<'py> {
+    pub fn new(
+        config: SerializationConfig,
+        warnings_mode: WarningsMode,
+        include: Option<Bound<'py, PyAny>>,
+        exclude: Option<Bound<'py, PyAny>>,
+    ) -> PyResult<Self> {
         let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = RecursionState::default();
         Ok(Self {
             warnings,
             rec_guard,
             config,
             field_name: None,
+            include_exclude: (include, exclude),
         })
     }
+}
 
+impl SerializationState<'_> {
     pub fn recursion_guard(
         &mut self,
         value: &Bound<'_, PyAny>,
@@ -109,6 +118,26 @@ impl<'py> SerializationState<'py> {
             value,
         }
     }
+
+    pub fn scoped_include_exclude<'scope>(
+        &'scope mut self,
+        next_include: Option<Bound<'py, PyAny>>,
+        next_exclude: Option<Bound<'py, PyAny>>,
+    ) -> ScopedIncludeExcludeState<'scope, 'py> {
+        self.scoped_set(SerializationState::include_exclude_mut, (next_include, next_exclude))
+    }
+
+    pub fn include(&self) -> Option<&Bound<'py, PyAny>> {
+        self.include_exclude.0.as_ref()
+    }
+
+    pub fn exclude(&self) -> Option<&Bound<'py, PyAny>> {
+        self.include_exclude.1.as_ref()
+    }
+
+    fn include_exclude_mut(&mut self) -> &mut (Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>) {
+        &mut self.include_exclude
+    }
 }
 
 /// Useful things which are passed around by type_serializers
@@ -174,7 +203,7 @@ impl<'a, 'py> Extra<'a, 'py> {
         value: &'slf Bound<'py, PyAny>,
         state: &'slf mut SerializationState<'py>,
     ) -> super::infer::SerializeInfer<'slf, 'py> {
-        super::infer::SerializeInfer::new(value, None, None, state, self)
+        super::infer::SerializeInfer::new(value, state, self)
     }
 
     pub(crate) fn model_type_name(&self) -> Option<Bound<'a, PyString>> {
@@ -223,6 +252,8 @@ pub(crate) struct ExtraOwned {
     pub fallback: Option<Py<PyAny>>,
     serialize_as_any: bool,
     pub context: Option<Py<PyAny>>,
+    include: Option<Py<PyAny>>,
+    exclude: Option<Py<PyAny>>,
 }
 
 #[derive(Clone)]
@@ -263,6 +294,8 @@ impl ExtraOwned {
             fallback: extra.fallback.map(|model| model.clone().into()),
             serialize_as_any: extra.serialize_as_any,
             context: extra.context.map(|model| model.clone().into()),
+            include: state.include().map(|m| m.clone().into()),
+            exclude: state.exclude().map(|m| m.clone().into()),
         }
     }
 
@@ -295,6 +328,10 @@ impl ExtraOwned {
                 Some(FieldNameOwned::Regular(b)) => Some(FieldName::Regular(b.bind(py).clone())),
                 None => None,
             },
+            include_exclude: (
+                self.include.as_ref().map(|m| m.bind(py).clone()),
+                self.exclude.as_ref().map(|m| m.bind(py).clone()),
+            ),
         }
     }
 }
@@ -528,3 +565,10 @@ where
         self.state
     }
 }
+
+type ScopedIncludeExcludeState<'scope, 'py> = ScopedSetState<
+    'scope,
+    'py,
+    for<'s> fn(&'s mut SerializationState<'py>) -> &'s mut (Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>),
+    (Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>),
+>;