fix union wrap combo

Author: davidhewitt

src/serializers/extra.rs

@@ -198,6 +198,10 @@ impl<'a> Extra<'a> {
     pub fn serialize_infer<'py>(&'py self, value: &'py Bound<'py, PyAny>) -> super::infer::SerializeInfer<'py> {
         super::infer::SerializeInfer::new(value, None, None, self)
     }
+
+    pub(crate) fn model_type_name(&self) -> Option<Bound<'a, PyString>> {
+        self.model.and_then(|model| model.get_type().name().ok())
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]

src/serializers/fields.rs

@@ -200,7 +200,15 @@ impl GeneralFieldsSerializer {
                     };
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
-                    return Err(PydanticSerializationUnexpectedValue::new_err(None));
+                    let type_name = field_extra.model_type_name();
+                    return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+                        "Unexpected field `{key}`{for_type_name}",
+                        for_type_name = if let Some(type_name) = type_name {
+                            format!(" for type `{type_name}`")
+                        } else {
+                            String::new()
+                        },
+                    ))));
                 }
             }
         }
@@ -212,22 +220,15 @@ impl GeneralFieldsSerializer {
             && self.required_fields > used_req_fields
         {
             let required_fields = self.required_fields;
-            let type_name = match extra.model {
-                Some(model) => model
-                    .get_type()
-                    .qualname()
-                    .ok()
-                    .unwrap_or_else(|| PyString::new_bound(py, "<unknown python object>"))
-                    .to_string(),
-                None => "<unknown python object>".to_string(),
-            };
+            let type_name = extra.model_type_name();
             let field_value = match extra.model {
                 Some(model) => truncate_safe_repr(model, Some(100)),
                 None => "<unknown python object>".to_string(),
             };
 
             Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
-                "Expected {required_fields} fields but got {used_req_fields} for type `{type_name}` with value `{field_value}` - serialized value may not be as expected."
+                "Expected {required_fields} fields but got {used_req_fields}{for_type_name} with value `{field_value}` - serialized value may not be as expected.",
+                for_type_name = if let Some(type_name) = type_name { format!(" for type `{type_name}`") } else { String::new() },
             ))))
         } else {
             Ok(output_dict)

src/serializers/type_serializers/function.rs

@@ -179,6 +179,13 @@ impl FunctionPlainSerializer {
             .expect("fallback_serializer unexpectedly none")
             .as_ref()
     }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.fallback_serializer
+            .as_ref()
+            .map_or(false, |f| f.retry_with_lax_check())
+            || self.return_serializer.retry_with_lax_check()
+    }
 }
 
 fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyResult<()> {
@@ -271,6 +278,10 @@ macro_rules! function_type_serializer {
             fn get_name(&self) -> &str {
                 &self.name
             }
+
+            fn retry_with_lax_check(&self) -> bool {
+                self.retry_with_lax_check()
+            }
         }
     };
 }
@@ -409,6 +420,10 @@ impl FunctionWrapSerializer {
     fn get_fallback_serializer(&self) -> &CombinedSerializer {
         self.serializer.as_ref()
     }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.serializer.retry_with_lax_check() || self.return_serializer.retry_with_lax_check()
+    }
 }
 
 impl_py_gc_traverse!(FunctionWrapSerializer {