feat: add on_error (#200)

* feat: add `on_error`

* use single quote

* no need for owned string

* add error message check

* add default_value

Author: PrettyWood

pydantic_core/_types.py

@@ -123,6 +123,7 @@ class TypedDictField(TypedDict, total=False):
     required: bool
     default: Any
     default_factory: Callable[[], Any]
+    on_error: Literal['raise', 'omit', 'fallback_on_default']  # default: 'raise'
     alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
 
 

src/validators/typed_dict.rs

@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFunction, PyList, PySet, PyString};
 use pyo3::{intern, PyTypeInfo};
@@ -13,17 +15,37 @@ use crate::SchemaError;
 
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
+#[derive(Debug, Clone)]
+enum OnError {
+    Raise,
+    Omit,
+    FallbackOnDefault,
+}
+
 #[derive(Debug, Clone)]
 struct TypedDictField {
     name: String,
     lookup_key: LookupKey,
     name_pystring: Py<PyString>,
     required: bool,
+    on_error: OnError,
     default: Option<PyObject>,
     default_factory: Option<PyObject>,
     validator: CombinedValidator,
 }
 
+impl TypedDictField {
+    fn default_value(&self, py: Python) -> PyResult<Option<Cow<PyObject>>> {
+        if let Some(ref default) = self.default {
+            Ok(Some(Cow::Borrowed(default)))
+        } else if let Some(ref default_factory) = self.default_factory {
+            Ok(Some(Cow::Owned(default_factory.call0(py)?)))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct TypedDictValidator {
     fields: Vec<TypedDictField>,
@@ -88,7 +110,7 @@ impl BuildValidator for TypedDictValidator {
             let field_name: &str = key.extract()?;
             let schema: &PyAny = field_info
                 .get_as_req(intern!(py, "schema"))
-                .map_err(|err| SchemaError::new_err(format!("Field \"{}\":\n  {}", field_name, err)))?;
+                .map_err(|err| SchemaError::new_err(format!("Field '{}':\n  {}", field_name, err)))?;
 
             let (default, default_factory) = match (
                 field_info.get_as(intern!(py, "default"))?,
@@ -107,6 +129,47 @@ impl BuildValidator for TypedDictValidator {
                 }
                 None => LookupKey::from_string(py, field_name),
             };
+
+            let required = match field_info.get_as::<bool>(intern!(py, "required"))? {
+                Some(required) => {
+                    if required && (default.is_some() || default_factory.is_some()) {
+                        return py_error!("Field '{}': a required field cannot have a default value", field_name);
+                    }
+                    required
+                }
+                None => full,
+            };
+
+            let on_error = match field_info.get_as::<&str>(intern!(py, "on_error"))? {
+                Some(on_error) => match on_error {
+                    "raise" => OnError::Raise,
+                    "omit" => {
+                        if required {
+                            return py_error!(
+                                "Field '{}': 'on_error = {}' cannot be set for required fields",
+                                field_name,
+                                on_error
+                            );
+                        }
+
+                        OnError::Omit
+                    }
+                    "fallback_on_default" => {
+                        if default.is_none() && default_factory.is_none() {
+                            return py_error!(
+                                "Field '{}': 'on_error = {}' requires a `default` or `default_factory`",
+                                field_name,
+                                on_error
+                            );
+                        }
+
+                        OnError::FallbackOnDefault
+                    }
+                    _ => unreachable!(),
+                },
+                None => OnError::Raise,
+            };
+
             fields.push(TypedDictField {
                 name: field_name.to_string(),
                 lookup_key,
@@ -115,17 +178,10 @@ impl BuildValidator for TypedDictValidator {
                     Ok((v, _)) => v,
                     Err(err) => return py_error!("Field \"{}\":\n  {}", field_name, err),
                 },
-                required: match field_info.get_as::<bool>(intern!(py, "required"))? {
-                    Some(required) => {
-                        if required && (default.is_some() || default_factory.is_some()) {
-                            return py_error!("Field \"{}\": a required field cannot have a default value", field_name);
-                        }
-                        required
-                    }
-                    None => full,
-                },
+                required,
                 default,
                 default_factory,
+                on_error,
             });
         }
         Ok(Self {
@@ -210,17 +266,23 @@ impl Validator for TypedDictValidator {
                                     fs.push(field.name_pystring.clone_ref(py));
                                 }
                             }
-                            Err(ValError::LineErrors(line_errors)) => {
-                                for err in line_errors {
-                                    errors.push(err.with_outer_location(field.name.clone().into()));
+                            Err(ValError::LineErrors(line_errors)) => match field.on_error {
+                                OnError::Raise => {
+                                    for err in line_errors {
+                                        errors.push(err.with_outer_location(field.name.clone().into()));
+                                    }
                                 }
-                            }
+                                OnError::Omit => continue,
+                                OnError::FallbackOnDefault => {
+                                    if let Some(default_value) = field.default_value(py)? {
+                                        output_dict.set_item(&field.name_pystring, default_value.as_ref())?;
+                                    }
+                                }
+                            },
                             Err(err) => return Err(err),
                         }
-                    } else if let Some(ref default) = field.default {
-                        output_dict.set_item(&field.name_pystring, default)?;
-                    } else if let Some(ref default_factory) = field.default_factory {
-                        output_dict.set_item(&field.name_pystring, default_factory.call0(py)?)?;
+                    } else if let Some(default_value) = field.default_value(py)? {
+                        output_dict.set_item(&field.name_pystring, default_value.as_ref())?
                     } else if !field.required {
                         continue;
                     } else {

tests/validators/test_typed_dict.py

@@ -449,7 +449,7 @@ def test_all_optional_fields_with_required_fields():
 
 def test_field_required_and_default():
     """A field cannot be required and have a default value"""
-    with pytest.raises(SchemaError, match='Field "x": a required field cannot have a default value'):
+    with pytest.raises(SchemaError, match="Field 'x': a required field cannot have a default value"):
         SchemaValidator(
             {'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}, 'required': True, 'default': 'pika'}}}
         )
@@ -1077,7 +1077,7 @@ def test_default_and_default_factory():
 
 def test_field_required_and_default_factory():
     """A field cannot be required and have a default factory"""
-    with pytest.raises(SchemaError, match='Field "x": a required field cannot have a default value'):
+    with pytest.raises(SchemaError, match="Field 'x': a required field cannot have a default value"):
         SchemaValidator(
             {
                 'type': 'typed-dict',
@@ -1099,3 +1099,115 @@ def test_bad_default_factory(default_factory, error_message):
     )
     with pytest.raises(TypeError, match=re.escape(error_message)):
         v.validate_python({})
+
+
+class TestOnError:
+    def test_on_error_bad_name(self):
+        with pytest.raises(SchemaError, match="Input should be one of: 'raise', 'omit', 'fallback_on_default'"):
+            SchemaValidator({'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'rais'}}})
+
+    def test_on_error_bad_omit(self):
+        with pytest.raises(SchemaError, match="Field 'x': 'on_error = omit' cannot be set for required fields"):
+            SchemaValidator({'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'omit'}}})
+
+    def test_on_error_bad_fallback_on_default(self):
+        with pytest.raises(
+            SchemaError, match="Field 'x': 'on_error = fallback_on_default' requires a `default` or `default_factory`"
+        ):
+            SchemaValidator(
+                {'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'fallback_on_default'}}}
+            )
+
+    def test_on_error_raise_by_default(self, py_and_json: PyAndJson):
+        v = py_and_json({'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}}}})
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        with pytest.raises(ValidationError) as exc_info:
+            v.validate_test({'x': ['foo']})
+        assert exc_info.value.errors() == [
+            {'input_value': ['foo'], 'kind': 'str_type', 'loc': ['x'], 'message': 'Input should be a valid string'}
+        ]
+
+    def test_on_error_raise_explicit(self, py_and_json: PyAndJson):
+        v = py_and_json({'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'raise'}}})
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        with pytest.raises(ValidationError) as exc_info:
+            v.validate_test({'x': ['foo']})
+        assert exc_info.value.errors() == [
+            {'input_value': ['foo'], 'kind': 'str_type', 'loc': ['x'], 'message': 'Input should be a valid string'}
+        ]
+
+    def test_on_error_omit(self, py_and_json: PyAndJson):
+        v = py_and_json(
+            {'type': 'typed-dict', 'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'omit', 'required': False}}}
+        )
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        assert v.validate_test({}) == {}
+        assert v.validate_test({'x': ['foo']}) == {}
+
+    def test_on_error_omit_with_default(self, py_and_json: PyAndJson):
+        v = py_and_json(
+            {
+                'type': 'typed-dict',
+                'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'omit', 'default': 'pika', 'required': False}},
+            }
+        )
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        assert v.validate_test({}) == {'x': 'pika'}
+        assert v.validate_test({'x': ['foo']}) == {}
+
+    def test_on_error_fallback_on_default(self, py_and_json: PyAndJson):
+        v = py_and_json(
+            {
+                'type': 'typed-dict',
+                'fields': {'x': {'schema': {'type': 'str'}, 'on_error': 'fallback_on_default', 'default': 'pika'}},
+            }
+        )
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        assert v.validate_test({'x': ['foo']}) == {'x': 'pika'}
+
+    def test_on_error_fallback_on_default_factory(self, py_and_json: PyAndJson):
+        v = py_and_json(
+            {
+                'type': 'typed-dict',
+                'fields': {
+                    'x': {
+                        'schema': {'type': 'str'},
+                        'on_error': 'fallback_on_default',
+                        'default_factory': lambda: 'pika',
+                    }
+                },
+            }
+        )
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        assert v.validate_test({'x': ['foo']}) == {'x': 'pika'}
+
+    def test_wrap_on_error(self, py_and_json: PyAndJson):
+        def wrap_function(input_value, *, validator, **kwargs):
+            try:
+                return validator(input_value)
+            except ValidationError:
+                if isinstance(input_value, list):
+                    return str(len(input_value))
+                else:
+                    return repr(input_value)
+
+        v = py_and_json(
+            {
+                'type': 'typed-dict',
+                'fields': {
+                    'x': {
+                        'schema': {
+                            'type': 'function',
+                            'mode': 'wrap',
+                            'function': wrap_function,
+                            'schema': {'type': 'str'},
+                        },
+                        'on_error': 'raise',
+                    }
+                },
+            }
+        )
+        assert v.validate_test({'x': 'foo'}) == {'x': 'foo'}
+        assert v.validate_test({'x': ['foo']}) == {'x': '1'}
+        assert v.validate_test({'x': ['foo', 'bar']}) == {'x': '2'}
+        assert v.validate_test({'x': {'a': 'b'}}) == {'x': "{'a': 'b'}"}