allow serialization functions to upgrade warnings to exceptions (#1258)

Signed-off-by: Lance Drane <[email protected]>
Signed-off-by: Lance-Drane <[email protected]>

Author: Lance-Drane

.mypy-stubtest-allowlist

@@ -2,3 +2,6 @@
 pydantic_core._pydantic_core.PydanticUndefinedType.new
 # As per #1240, from_json has custom logic to coverage the `cache_strings` kwarg
 pydantic_core._pydantic_core.from_json
+# the `warnings` kwarg for SchemaSerializer functions has custom logic
+pydantic_core._pydantic_core.SchemaSerializer.to_python
+pydantic_core._pydantic_core.SchemaSerializer.to_json

python/pydantic_core/_pydantic_core.pyi

@@ -264,7 +264,7 @@ class SchemaSerializer:
         exclude_defaults: bool = False,
         exclude_none: bool = False,
         round_trip: bool = False,
-        warnings: bool = True,
+        warnings: bool | Literal['none', 'warn', 'error'] = True,
         fallback: Callable[[Any], Any] | None = None,
         serialize_as_any: bool = False,
         context: dict[str, Any] | None = None,
@@ -284,7 +284,8 @@ class SchemaSerializer:
             exclude_defaults: Whether to exclude fields that are equal to their default value.
             exclude_none: Whether to exclude fields that have a value of `None`.
             round_trip: Whether to enable serialization and validation round-trip support.
-            warnings: Whether to log warnings when invalid fields are encountered.
+            warnings: How to handle invalid fields. False/"none" ignores them, True/"warn" logs errors,
+                "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
             serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
@@ -309,7 +310,7 @@ class SchemaSerializer:
         exclude_defaults: bool = False,
         exclude_none: bool = False,
         round_trip: bool = False,
-        warnings: bool = True,
+        warnings: bool | Literal['none', 'warn', 'error'] = True,
         fallback: Callable[[Any], Any] | None = None,
         serialize_as_any: bool = False,
         context: dict[str, Any] | None = None,
@@ -328,7 +329,8 @@ class SchemaSerializer:
             exclude_defaults: Whether to exclude fields that are equal to their default value.
             exclude_none: Whether to exclude fields that have a value of `None`.
             round_trip: Whether to enable serialization and validation round-trip support.
-            warnings: Whether to log warnings when invalid fields are encountered.
+            warnings: How to handle invalid fields. False/"none" ignores them, True/"warn" logs errors,
+                "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
             serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.

src/lib.rs

@@ -34,6 +34,7 @@ pub use errors::{
 };
 pub use serializers::{
     to_json, to_jsonable_python, PydanticSerializationError, PydanticSerializationUnexpectedValue, SchemaSerializer,
+    WarningsArg,
 };
 pub use validators::{validate_core_schema, PySome, SchemaValidator};
 

src/serializers/extra.rs

@@ -1,9 +1,10 @@
 use std::cell::RefCell;
 use std::fmt;
 
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::types::PyBool;
 
 use serde::ser::Error;
 
@@ -14,6 +15,7 @@ use crate::recursion_guard::ContainsRecursionState;
 use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
 use crate::recursion_guard::RecursionState;
+use crate::PydanticSerializationError;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
 /// then `SerializationState` got a `serialize_infer` method, but I couldn't get it to work
@@ -64,7 +66,7 @@ impl DuckTypingSerMode {
 
 impl SerializationState {
     pub fn new(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
-        let warnings = CollectWarnings::new(false);
+        let warnings = CollectWarnings::new(WarningsMode::None);
         let rec_guard = SerRecursionState::default();
         let config = SerializationConfig::from_args(timedelta_mode, bytes_mode, inf_nan_mode)?;
         Ok(Self {
@@ -325,23 +327,61 @@ impl ToPyObject for SerMode {
     }
 }
 
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum WarningsMode {
+    None,
+    Warn,
+    Error,
+}
+
+impl<'py> FromPyObject<'py> for WarningsMode {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<WarningsMode> {
+        if let Ok(bool_mode) = ob.downcast::<PyBool>() {
+            Ok(bool_mode.is_true().into())
+        } else if let Ok(str_mode) = ob.extract::<&str>() {
+            match str_mode {
+                "none" => Ok(Self::None),
+                "warn" => Ok(Self::Warn),
+                "error" => Ok(Self::Error),
+                _ => Err(PyValueError::new_err(
+                    "Invalid warnings parameter, should be `'none'`, `'warn'`, `'error'` or a `bool`",
+                )),
+            }
+        } else {
+            Err(PyTypeError::new_err(
+                "Invalid warnings parameter, should be `'none'`, `'warn'`, `'error'` or a `bool`",
+            ))
+        }
+    }
+}
+
+impl From<bool> for WarningsMode {
+    fn from(mode: bool) -> Self {
+        if mode {
+            Self::Warn
+        } else {
+            Self::None
+        }
+    }
+}
+
 #[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct CollectWarnings {
-    active: bool,
+    mode: WarningsMode,
     warnings: RefCell<Option<Vec<String>>>,
 }
 
 impl CollectWarnings {
-    pub(crate) fn new(active: bool) -> Self {
+    pub(crate) fn new(mode: WarningsMode) -> Self {
         Self {
-            active,
+            mode,
             warnings: RefCell::new(None),
         }
     }
 
     pub fn custom_warning(&self, warning: String) {
-        if self.active {
+        if self.mode != WarningsMode::None {
             self.add_warning(warning);
         }
     }
@@ -379,7 +419,7 @@ impl CollectWarnings {
     }
 
     fn fallback_warning(&self, field_type: &str, value: &Bound<'_, PyAny>) {
-        if self.active {
+        if self.mode != WarningsMode::None {
             let type_name = value
                 .get_type()
                 .qualname()
@@ -400,17 +440,20 @@ impl CollectWarnings {
     }
 
     pub fn final_check(&self, py: Python) -> PyResult<()> {
-        if self.active {
-            match *self.warnings.borrow() {
-                Some(ref warnings) => {
-                    let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
+        if self.mode == WarningsMode::None {
+            return Ok(());
+        }
+        match *self.warnings.borrow() {
+            Some(ref warnings) => {
+                let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
+                if self.mode == WarningsMode::Warn {
                     let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
                     PyErr::warn_bound(py, &user_warning_type, &message, 0)
+                } else {
+                    Err(PydanticSerializationError::new_err(message))
                 }
-                _ => Ok(()),
             }
-        } else {
-            Ok(())
+            _ => Ok(()),
         }
     }
 }

src/serializers/mod.rs

@@ -10,7 +10,7 @@ use crate::py_gc::PyGcTraverse;
 
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
-use extra::{CollectWarnings, SerRecursionState};
+use extra::{CollectWarnings, SerRecursionState, WarningsMode};
 pub(crate) use extra::{DuckTypingSerMode, Extra, SerMode, SerializationState};
 pub use shared::CombinedSerializer;
 use shared::{to_json_bytes, BuildSerializer, TypeSerializer};
@@ -27,6 +27,12 @@ pub mod ser;
 mod shared;
 mod type_serializers;
 
+#[derive(FromPyObject)]
+pub enum WarningsArg {
+    Bool(bool),
+    Literal(WarningsMode),
+}
+
 #[pyclass(module = "pydantic_core._pydantic_core", frozen)]
 #[derive(Debug)]
 pub struct SchemaSerializer {
@@ -98,7 +104,7 @@ impl SchemaSerializer {
 
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, mode = None, include = None, exclude = None, by_alias = true,
-        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
+        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = WarningsArg::Bool(true),
         fallback = None, serialize_as_any = false, context = None))]
     pub fn to_python(
         &self,
@@ -112,13 +118,17 @@ impl SchemaSerializer {
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
-        warnings: bool,
+        warnings: WarningsArg,
         fallback: Option<&Bound<'_, PyAny>>,
         serialize_as_any: bool,
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
-        let warnings = CollectWarnings::new(warnings);
+        let warnings_mode = match warnings {
+            WarningsArg::Bool(b) => b.into(),
+            WarningsArg::Literal(mode) => mode,
+        };
+        let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = SerRecursionState::default();
         let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
@@ -143,7 +153,7 @@ impl SchemaSerializer {
 
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
-        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
+        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = WarningsArg::Bool(true),
         fallback = None, serialize_as_any = false, context = None))]
     pub fn to_json(
         &self,
@@ -157,12 +167,16 @@ impl SchemaSerializer {
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
-        warnings: bool,
+        warnings: WarningsArg,
         fallback: Option<&Bound<'_, PyAny>>,
         serialize_as_any: bool,
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
-        let warnings = CollectWarnings::new(warnings);
+        let warnings_mode = match warnings {
+            WarningsArg::Bool(b) => b.into(),
+            WarningsArg::Literal(mode) => mode,
+        };
+        let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = SerRecursionState::default();
         let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(

tests/serializers/test_list_tuple.py

@@ -4,7 +4,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
+from pydantic_core import PydanticSerializationError, SchemaError, SchemaSerializer, core_schema, validate_core_schema
 
 
 def test_list_any():
@@ -52,6 +52,16 @@ def test_list_str_fallback():
         '  Expected `str` but got `int` - serialized value may not be as expected\n'
         '  Expected `str` but got `int` - serialized value may not be as expected'
     ]
+    with pytest.raises(PydanticSerializationError) as warning_ex:
+        v.to_json([1, 2, 3], warnings='error')
+    assert str(warning_ex.value) == ''.join(
+        [
+            'Pydantic serializer warnings:\n'
+            '  Expected `str` but got `int` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` - serialized value may not be as expected'
+        ]
+    )
 
 
 def test_tuple_any():

tests/serializers/test_string.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from pydantic_core import SchemaSerializer, core_schema
+from pydantic_core import PydanticSerializationError, SchemaSerializer, core_schema
 
 
 def test_str():
@@ -34,13 +34,44 @@ def test_str_fallback():
         assert s.to_python(123, mode='json') == 123
     with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
         assert s.to_json(123) == b'123'
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, warnings='warn') == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, mode='json', warnings='warn') == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_json(123, warnings='warn') == b'123'
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, warnings=True) == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, mode='json', warnings=True) == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_json(123, warnings=True) == b'123'
 
 
 def test_str_no_warnings():
     s = SchemaSerializer(core_schema.str_schema())
     assert s.to_python(123, warnings=False) == 123
+    assert s.to_python(123, warnings='none') == 123
     assert s.to_python(123, mode='json', warnings=False) == 123
+    assert s.to_python(123, mode='json', warnings='none') == 123
     assert s.to_json(123, warnings=False) == b'123'
+    assert s.to_json(123, warnings='none') == b'123'
+
+
+def test_str_errors():
+    s = SchemaSerializer(core_schema.str_schema())
+    with pytest.raises(
+        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+    ):
+        assert s.to_python(123, warnings='error') == 123
+    with pytest.raises(
+        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+    ):
+        assert s.to_python(123, mode='json', warnings='error') == 123
+    with pytest.raises(
+        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+    ):
+        assert s.to_json(123, warnings='error') == b'123'
 
 
 class StrSubclass(str):

tests/test.rs

@@ -1,6 +1,6 @@
 #[cfg(test)]
 mod tests {
-    use _pydantic_core::{SchemaSerializer, SchemaValidator};
+    use _pydantic_core::{SchemaSerializer, SchemaValidator, WarningsArg};
     use pyo3::prelude::*;
     use pyo3::types::PyDict;
 
@@ -85,7 +85,20 @@ a = A()
             let serialized = SchemaSerializer::py_new(schema, None)
                 .unwrap()
                 .to_json(
-                    py, &a, None, None, None, true, false, false, false, false, true, None, false, None,
+                    py,
+                    &a,
+                    None,
+                    None,
+                    None,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    WarningsArg::Bool(true),
+                    None,
+                    false,
+                    None,
                 )
                 .unwrap();
             let serialized: &[u8] = serialized.extract(py).unwrap();
@@ -186,7 +199,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     false,
-                    false,
+                    WarningsArg::Bool(false),
                     None,
                     false,
                     None,
@@ -207,7 +220,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     false,
-                    false,
+                    WarningsArg::Bool(false),
                     None,
                     false,
                     None,