require validators to support partial

Author: samuelcolvin

src/input/return_enums.rs

@@ -130,7 +130,7 @@ pub(crate) fn validate_iter_to_vec<'py>(
     let mut errors: Vec<ValLineError> = Vec::new();
 
     for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
-        state.allow_partial = is_last_partial;
+        state.allow_partial = is_last_partial && validator.supports_partial();
         let item = item_result.map_err(|e| any_next_error!(py, e, max_length_check.input, index))?;
         match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
@@ -203,7 +203,7 @@ pub(crate) fn validate_iter_to_set<'py>(
     let mut errors: Vec<ValLineError> = Vec::new();
 
     for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
-        state.allow_partial = is_last_partial;
+        state.allow_partial = is_last_partial && validator.supports_partial();
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
         match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {

src/validators/dict.rs

@@ -87,6 +87,10 @@ impl Validator for DictValidator {
     fn get_name(&self) -> &str {
         &self.name
     }
+
+    fn supports_partial(&self) -> bool {
+        true
+    }
 }
 
 struct ValidateToDict<'a, 's, 'py, I: Input<'py> + ?Sized> {
@@ -125,7 +129,7 @@ where
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
-            self.state.allow_partial = is_last_partial;
+            self.state.allow_partial = is_last_partial && self.value_validator.supports_partial();
             let output_value = match self.value_validator.validate(self.py, value.borrow_input(), self.state) {
                 Ok(value) => value,
                 Err(ValError::LineErrors(line_errors)) => {

src/validators/frozenset.rs

@@ -52,6 +52,10 @@ impl Validator for FrozenSetValidator {
     fn get_name(&self) -> &str {
         &self.name
     }
+
+    fn supports_partial(&self) -> bool {
+        true
+    }
 }
 
 struct ValidateToFrozenSet<'a, 's, 'py, I: Input<'py> + ?Sized> {

src/validators/generator.rs

@@ -227,7 +227,6 @@ pub struct InternalValidator {
     hide_input_in_errors: bool,
     validation_error_cause: bool,
     cache_str: jiter::StringCacheMode,
-    allow_partial: bool,
 }
 
 impl fmt::Debug for InternalValidator {
@@ -260,7 +259,6 @@ impl InternalValidator {
             hide_input_in_errors,
             validation_error_cause,
             cache_str: extra.cache_str,
-            allow_partial: state.allow_partial,
         }
     }
 
@@ -281,7 +279,7 @@ impl InternalValidator {
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard, self.allow_partial);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false);
         state.exactness = self.exactness;
         let result = self
             .validator
@@ -316,7 +314,7 @@ impl InternalValidator {
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard, self.allow_partial);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false);
         state.exactness = self.exactness;
         let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(

src/validators/list.rs

@@ -177,6 +177,10 @@ impl Validator for ListValidator {
             }
         }
     }
+
+    fn supports_partial(&self) -> bool {
+        true
+    }
 }
 
 struct ValidateToVec<'a, 's, 'py, I: Input<'py> + ?Sized> {

src/validators/mod.rs

@@ -365,7 +365,7 @@ impl SchemaValidator {
                 self.cache_str,
             ),
             &mut recursion_guard,
-            allow_partial,
+            allow_partial && self.validator.supports_partial(),
         );
         self.validator.validate(py, input, &mut state)
     }
@@ -801,4 +801,10 @@ pub trait Validator: Send + Sync + Debug {
     /// `get_name` generally returns `Self::EXPECTED_TYPE` or some other clear identifier of the validator
     /// this is used in the error location in unions, and in the top level message in `ValidationError`
     fn get_name(&self) -> &str;
+
+    /// Whether this validator supports partial validation, `state.allow_partial` should only be set to true
+    /// if this is the case.
+    fn supports_partial(&self) -> bool {
+        false
+    }
 }

src/validators/set.rs

@@ -83,6 +83,10 @@ impl Validator for SetValidator {
     fn get_name(&self) -> &str {
         &self.name
     }
+
+    fn supports_partial(&self) -> bool {
+        true
+    }
 }
 
 struct ValidateToSet<'a, 's, 'py, I: Input<'py> + ?Sized> {

src/validators/typed_dict.rs

@@ -156,7 +156,7 @@ impl Validator for TypedDictValidator {
         let output_dict = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
 
-        let partial_last_key = if self.allow_partial && state.allow_partial {
+        let partial_last_key = if state.allow_partial {
             dict.last_key().map(Into::into)
         } else {
             None
@@ -201,7 +201,7 @@ impl Validator for TypedDictValidator {
                     } else {
                         false
                     };
-                    state.allow_partial = is_last_partial;
+                    state.allow_partial = is_last_partial && field.validator.supports_partial();
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             output_dict.set_item(&field.name_py, value)?;
@@ -316,7 +316,7 @@ impl Validator for TypedDictValidator {
                                     } else {
                                         false
                                     };
-                                    self.state.allow_partial = last_partial;
+                                    self.state.allow_partial = last_partial && validator.supports_partial();
                                     match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
                                             self.output_dict.set_item(py_key, value)?;
@@ -363,28 +363,8 @@ impl Validator for TypedDictValidator {
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-}
 
-// impl TypedDictValidator {
-//     /// If we're in `allow_partial` mode, whether all errors occurred in the last value of the dict.
-//     fn valid_as_partial(
-//         &self,
-//         state: &ValidationState,
-//         get_opt_last_key: impl FnOnce() -> Option<LocItem>,
-//         errors: &[ValLineError],
-//     ) -> bool {
-//         if !state.allow_partial || !self.allow_partial {
-//             false
-//         } else if let Some(last_key) = get_opt_last_key() {
-//             errors.iter().all(|error| {
-//                 if let Some(loc_item) = error.first_loc_item() {
-//                     loc_item == &last_key
-//                 } else {
-//                     false
-//                 }
-//             })
-//         } else {
-//             false
-//         }
-//     }
-// }
+    fn supports_partial(&self) -> bool {
+        self.allow_partial
+    }
+}

tests/validators/test_allow_partial.py

@@ -38,29 +38,6 @@ def test_list():
     assert v.validate_json(b'[[1, 2], [3,', allow_partial=True) == [(1, 2)]
 
 
-def test_list_partial_nested():
-    v = SchemaValidator(
-        core_schema.tuple_positional_schema(
-            [core_schema.int_schema(), core_schema.list_schema(core_schema.int_schema())]
-        ),
-    )
-    assert v.validate_python([1, [2, 3]]) == (1, [2, 3])
-    assert v.validate_python([1, [2, 3]], allow_partial=True) == (1, [2, 3])
-    with pytest.raises(ValidationError) as exc_info:
-        v.validate_python((1, [2, 3, 'x']))
-    assert exc_info.value.errors(include_url=False) == snapshot(
-        [
-            {
-                'type': 'int_parsing',
-                'loc': (1, 2),
-                'msg': 'Input should be a valid integer, unable to parse string as an integer',
-                'input': 'x',
-            }
-        ]
-    )
-    assert v.validate_python((1, [2, 3, 'x']), allow_partial=True) == (1, [2, 3])
-
-
 @pytest.mark.parametrize('collection_type', [core_schema.set_schema, core_schema.frozenset_schema])
 def test_set_frozenset(collection_type):
     v = SchemaValidator(
@@ -253,3 +230,17 @@ def test_double_nested():
     for i in range(1, len(json)):
         value = v.validate_json(json[:i], allow_partial=True)
         assert isinstance(value, dict)
+
+
+def test_tuple_list():
+    """Tuples don't support partial, so behaviour should be disabled."""
+    v = SchemaValidator(
+        core_schema.tuple_positional_schema(
+            [core_schema.list_schema(core_schema.int_schema()), core_schema.int_schema()]
+        ),
+    )
+    assert v.validate_python([['1', '2'], '3'], allow_partial=True) == snapshot(([1, 2], 3))
+    with pytest.raises(ValidationError, match=r'1\s+Input should be a valid integer'):
+        v.validate_python([['1', '2'], 'x'], allow_partial=True)
+    with pytest.raises(ValidationError, match=r'0\.1\s+Input should be a valid integer'):
+        v.validate_python([['1', 'x'], '2'], allow_partial=True)