Defer pyobject introspection until warnings are actually raised, leading to perf boost for union serialization

Author: sydney-runkle

src/serializers/errors.rs

@@ -2,6 +2,9 @@ use std::fmt;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
+use pyo3::types::PyString;
+
+use crate::tools::truncate_safe_repr;
 
 use serde::ser;
 
@@ -44,9 +47,9 @@ pub(super) fn se_err_py_err(error: PythonSerializerError) -> PyErr {
     let s = error.to_string();
     if let Some(msg) = s.strip_prefix(UNEXPECTED_TYPE_SER_MARKER) {
         if msg.is_empty() {
-            PydanticSerializationUnexpectedValue::new_err(None)
+            PydanticSerializationUnexpectedValue::new_from_msg(None)
         } else {
-            PydanticSerializationUnexpectedValue::new_err(Some(msg.to_string()))
+            PydanticSerializationUnexpectedValue::new_from_msg(Some(msg.to_string()))
         }
     } else if let Some(msg) = s.strip_prefix(SERIALIZATION_ERR_MARKER) {
         PydanticSerializationError::new_err(msg.to_string())
@@ -94,30 +97,57 @@ impl PydanticSerializationError {
 #[derive(Debug, Clone)]
 pub struct PydanticSerializationUnexpectedValue {
     message: Option<String>,
+    field_type: Option<String>,
+    input_value: Option<PyObject>,
 }
 
 impl PydanticSerializationUnexpectedValue {
-    pub(crate) fn new_err(msg: Option<String>) -> PyErr {
-        PyErr::new::<Self, Option<String>>(msg)
+    pub fn new_from_msg(message: Option<String>) -> PyErr {
+        PyErr::new::<Self, (Option<String>, Option<String>, Option<PyObject>)>((message, None, None))
+    }
+
+    pub fn new_from_parts(field_type: String, input_value: PyObject) -> PyErr {
+        PyErr::new::<Self, (Option<String>, Option<String>, Option<PyObject>)>((
+            None,
+            Some(field_type),
+            Some(input_value),
+        ))
     }
 }
 
 #[pymethods]
 impl PydanticSerializationUnexpectedValue {
     #[new]
-    #[pyo3(signature = (message=None))]
-    fn py_new(message: Option<String>) -> Self {
-        Self { message }
+    #[pyo3(signature = (message=None, field_type=None, input_value=None))]
+    fn py_new(message: Option<String>, field_type: Option<String>, input_value: Option<PyObject>) -> Self {
+        Self {
+            message,
+            field_type,
+            input_value,
+        }
     }
 
-    fn __str__(&self) -> &str {
-        match self.message {
-            Some(ref s) => s,
-            None => "Unexpected Value",
+    fn __str__(&self, py: Python) -> String {
+        match &self.message {
+            Some(s) => s.to_string(),
+            None => match (&self.field_type, &self.input_value) {
+                (Some(ref field_type), Some(ref input_value)) => {
+                    let bound_input = input_value.bind(py);
+
+                    let type_name = bound_input
+                        .get_type()
+                        .qualname()
+                        .unwrap_or_else(|_| PyString::new(py, "<unknown python object>"));
+
+                    let value_str = truncate_safe_repr(bound_input, None);
+                    format!("Expected `{field_type}` but got `{type_name}` with value `{value_str}` - serialized value may not be as expected")
+                }
+                _ => "Unexpected value - serialized value may not be as expected".to_string(),
+            },
         }
     }
 
-    pub(crate) fn __repr__(&self) -> String {
-        format!("PydanticSerializationUnexpectedValue({})", self.__str__())
+    pub(crate) fn __repr__(&self, py: Python) -> String {
+        format!("PydanticSerializationUnexpectedValue({})", self.__str__(py))
     }
 }

src/serializers/extra.rs

@@ -3,6 +3,7 @@ use std::ffi::CString;
 use std::fmt;
 use std::sync::Mutex;
 
+use crate::tools::truncate_safe_repr;
 use pyo3::exceptions::{PyTypeError, PyUserWarning, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyBool, PyString};
@@ -17,7 +18,6 @@ use crate::recursion_guard::ContainsRecursionState;
 use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
 use crate::recursion_guard::RecursionState;
-use crate::tools::truncate_safe_repr;
 use crate::PydanticSerializationError;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
@@ -415,15 +415,10 @@ impl CollectWarnings {
         if value.is_none() {
             Ok(())
         } else if extra.check.enabled() {
-            let type_name = value
-                .get_type()
-                .qualname()
-                .unwrap_or_else(|_| PyString::new(value.py(), "<unknown python object>"));
-
-            let value_str = truncate_safe_repr(value, None);
-            Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
-                "Expected `{field_type}` but got `{type_name}` with value `{value_str}` - serialized value may not be as expected"
-            ))))
+            Err(PydanticSerializationUnexpectedValue::new_from_parts(
+                field_type.to_string(),
+                value.clone().unbind(),
+            ))
         } else {
             self.fallback_warning(field_type, value);
             Ok(())

src/serializers/fields.rs

@@ -202,7 +202,7 @@ impl GeneralFieldsSerializer {
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
                     let type_name = field_extra.model_type_name();
-                    return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+                    return Err(PydanticSerializationUnexpectedValue::new_from_msg(Some(format!(
                         "Unexpected field `{key}`{for_type_name}",
                         for_type_name = if let Some(type_name) = type_name {
                             format!(" for type `{type_name}`")
@@ -227,7 +227,7 @@ impl GeneralFieldsSerializer {
                 None => "<unknown python object>".to_string(),
             };
 
-            Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+            Err(PydanticSerializationUnexpectedValue::new_from_msg(Some(format!(
                 "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() },
             ))))

src/serializers/type_serializers/datetime_etc.rs

@@ -34,7 +34,7 @@ fn downcast_date_reject_datetime<'a, 'py>(py_date: &'a Bound<'py, PyAny>) -> PyR
         }
     }
 
-    Err(PydanticSerializationUnexpectedValue::new_err(None))
+    Err(PydanticSerializationUnexpectedValue::new_from_msg(None))
 }
 
 macro_rules! build_serializer {

src/serializers/type_serializers/float.rs

@@ -75,7 +75,7 @@ impl TypeSerializer for FloatSerializer {
         match extra.ob_type_lookup.is_type(value, ObType::Float) {
             IsType::Exact => Ok(value.clone().unbind()),
             IsType::Subclass => match extra.check {
-                SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
+                SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_from_msg(None)),
                 SerCheck::Lax | SerCheck::None => match extra.mode {
                     SerMode::Json => value.extract::<f64>()?.into_py_any(py),
                     _ => infer_to_python(value, include, exclude, extra),

src/serializers/type_serializers/function.rs

@@ -194,7 +194,7 @@ fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyRes
         if extra.check.enabled() {
             Err(err)
         } else {
-            extra.warnings.custom_warning(ser_err.__repr__());
+            extra.warnings.custom_warning(ser_err.__repr__(py));
             Ok(())
         }
     } else if let Ok(err) = exception.extract::<PydanticSerializationError>() {

src/serializers/type_serializers/model.rs

@@ -190,7 +190,7 @@ impl TypeSerializer for ModelSerializer {
             let py = value.py();
             let root = value.getattr(intern!(py, ROOT_FIELD)).map_err(|original_err| {
                 if root_extra.check.enabled() {
-                    PydanticSerializationUnexpectedValue::new_err(None)
+                    PydanticSerializationUnexpectedValue::new_from_msg(None)
                 } else {
                     original_err
                 }

src/serializers/type_serializers/simple.rs

@@ -123,7 +123,7 @@ macro_rules! build_simple_serializer {
                 match extra.ob_type_lookup.is_type(value, $ob_type) {
                     IsType::Exact => Ok(value.clone().unbind()),
                     IsType::Subclass => match extra.check {
-                        SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
+                        SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_from_msg(None)),
                         SerCheck::Lax | SerCheck::None => match extra.mode {
                             SerMode::Json => value.extract::<$rust_type>()?.into_py_any(py),
                             _ => infer_to_python(value, include, exclude, extra),

src/serializers/type_serializers/tuple.rs

@@ -214,7 +214,7 @@ impl TupleSerializer {
                 .chain(self.serializers[variadic_item_index + 1..].iter());
             use_serializers!(serializers_iter);
         } else if extra.check == SerCheck::Strict && n_items != self.serializers.len() {
-            return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+            return Err(PydanticSerializationUnexpectedValue::new_from_msg(Some(format!(
                 "Expected {} items, but got {}",
                 self.serializers.len(),
                 n_items

src/serializers/type_serializers/union.rs

@@ -111,7 +111,7 @@ fn union_serialize<S>(
     // care of the formatting for us
     else if !errors.is_empty() {
         let message = errors.iter().map(ToString::to_string).collect::<Vec<_>>().join("\n");
-        return Err(PydanticSerializationUnexpectedValue::new_err(Some(message)));
+        return Err(PydanticSerializationUnexpectedValue::new_from_msg(Some(message)));
     }
 
     Ok(None)