move allow_partial to state, and set it correctly

Author: samuelcolvin

src/input/return_enums.rs

@@ -17,7 +17,7 @@ use pyo3::types::{PyBytes, PyComplex, PyFloat, PyFrozenSet, PyIterator, PyMappin
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{
-    py_err_string, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ToErrorValue, ValError, ValLineError, ValResult,
+    py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ToErrorValue, ValError, ValLineError, ValResult,
 };
 use crate::py_gc::PyGcTraverse;
 use crate::tools::{extract_i64, extract_int, new_py_string, py_err};
@@ -128,8 +128,9 @@ pub(crate) fn validate_iter_to_vec<'py>(
 ) -> ValResult<Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
-    let mut index = 0;
-    for item_result in iter {
+
+    for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
+        state.allow_partial = is_last_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) => {
@@ -138,41 +139,25 @@ pub(crate) fn validate_iter_to_vec<'py>(
             }
             Err(ValError::LineErrors(line_errors)) => {
                 max_length_check.incr()?;
-                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
-                if fail_fast {
-                    return Err(ValError::LineErrors(errors));
+                if !is_last_partial {
+                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                    if fail_fast {
+                        return Err(ValError::LineErrors(errors));
+                    }
                 }
             }
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
         }
-        index += 1;
     }
 
-    if errors.is_empty() || sequence_valid_as_partial(state, index, &errors) {
+    if errors.is_empty() {
         Ok(output)
     } else {
         Err(ValError::LineErrors(errors))
     }
 }
 
-/// If we're in `allow_partial` mode, whether all errors occurred in the last element of the input.
-pub fn sequence_valid_as_partial(state: &ValidationState, input_length: usize, errors: &[ValLineError]) -> bool {
-    if !state.extra().allow_partial {
-        false
-    } else {
-        // for the error to be in the last element, the index of all errors must be `input_length - 1`
-        let last_index = (input_length - 1) as i64;
-        errors.iter().all(|error| {
-            if let Some(LocItem::I(loc_index)) = error.first_loc_item() {
-                *loc_index == last_index
-            } else {
-                false
-            }
-        })
-    }
-}
-
 pub trait BuildSet {
     fn build_add(&self, item: PyObject) -> PyResult<()>;
 
@@ -216,8 +201,9 @@ pub(crate) fn validate_iter_to_set<'py>(
     fail_fast: bool,
 ) -> ValResult<()> {
     let mut errors: Vec<ValLineError> = Vec::new();
-    let mut index = 0;
-    for item_result in iter {
+
+    for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
+        state.allow_partial = is_last_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) => {
@@ -240,18 +226,19 @@ pub(crate) fn validate_iter_to_set<'py>(
                 }
             }
             Err(ValError::LineErrors(line_errors)) => {
-                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                if !is_last_partial {
+                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                }
             }
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
         }
         if fail_fast && !errors.is_empty() {
             return Err(ValError::LineErrors(errors));
         }
-        index += 1;
     }
 
-    if errors.is_empty() || sequence_valid_as_partial(state, index, &errors) {
+    if errors.is_empty() {
         Ok(())
     } else {
         Err(ValError::LineErrors(errors))

src/validators/dict.rs

@@ -109,13 +109,9 @@ where
     fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> ValResult<PyObject> {
         let output = PyDict::new_bound(self.py);
         let mut errors: Vec<ValLineError> = Vec::new();
-        // this should only be set to if:
-        // we get errors in a value, there are no previous errors, and no items come after that
-        // e.g. if we get errors just in the last value
-        let mut errors_in_last = false;
 
-        for item_result in iterator {
-            errors_in_last = false;
+        for (_, is_last_partial, item_result) in self.state.enumerate_last_partial(iterator) {
+            self.state.allow_partial = false;
             let (key, value) = item_result?;
             let output_key = match self.key_validator.validate(self.py, key.borrow_input(), self.state) {
                 Ok(value) => Some(value),
@@ -129,12 +125,12 @@ where
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
+            self.state.allow_partial = is_last_partial;
             let output_value = match self.value_validator.validate(self.py, value.borrow_input(), self.state) {
                 Ok(value) => value,
                 Err(ValError::LineErrors(line_errors)) => {
-                    errors_in_last = errors.is_empty();
-                    for err in line_errors {
-                        errors.push(err.with_outer_location(key.clone()));
+                    if !is_last_partial {
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(key.clone())));
                     }
                     continue;
                 }
@@ -146,7 +142,7 @@ where
             }
         }
 
-        if errors.is_empty() || (self.state.extra().allow_partial && errors_in_last) {
+        if errors.is_empty() {
             let input = self.input;
             length_check!(input, "Dictionary", self.min_length, self.max_length, output);
             Ok(output.into())

src/validators/generator.rs

@@ -260,7 +260,7 @@ impl InternalValidator {
             hide_input_in_errors,
             validation_error_cause,
             cache_str: extra.cache_str,
-            allow_partial: extra.allow_partial,
+            allow_partial: state.allow_partial,
         }
     }
 
@@ -280,9 +280,8 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
-            allow_partial: self.allow_partial,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, self.allow_partial);
         state.exactness = self.exactness;
         let result = self
             .validator
@@ -316,9 +315,8 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
-            allow_partial: self.allow_partial,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, self.allow_partial);
         state.exactness = self.exactness;
         let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(

src/validators/mod.rs

@@ -280,11 +280,10 @@ impl SchemaValidator {
             context,
             self_instance: None,
             cache_str: self.cache_str,
-            allow_partial: false,
         };
 
         let guard = &mut RecursionState::default();
-        let mut state = ValidationState::new(extra, guard);
+        let mut state = ValidationState::new(extra, guard, false);
         self.validator
             .validate_assignment(py, &obj, field_name, &field_value, &mut state)
             .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
@@ -305,10 +304,9 @@ impl SchemaValidator {
             context,
             self_instance: None,
             cache_str: self.cache_str,
-            allow_partial: false,
         };
         let recursion_guard = &mut RecursionState::default();
-        let mut state = ValidationState::new(extra, recursion_guard);
+        let mut state = ValidationState::new(extra, recursion_guard, false);
         let r = self.validator.default_value(py, None::<i64>, &mut state);
         match r {
             Ok(maybe_default) => match maybe_default {
@@ -365,9 +363,9 @@ impl SchemaValidator {
                 self_instance,
                 input_type,
                 self.cache_str,
-                allow_partial,
             ),
             &mut recursion_guard,
+            allow_partial,
         );
         self.validator.validate(py, input, &mut state)
     }
@@ -430,8 +428,9 @@ impl<'py> SelfValidator<'py> {
         let py = schema.py();
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
-            Extra::new(strict, None, None, None, InputType::Python, true.into(), false),
+            Extra::new(strict, None, None, None, InputType::Python, true.into()),
             &mut recursion_guard,
+            false,
         );
         match self.validator.validator.validate(py, schema, &mut state) {
             Ok(schema_obj) => Ok(schema_obj.into_bound(py)),
@@ -628,8 +627,6 @@ pub struct Extra<'a, 'py> {
     self_instance: Option<&'a Bound<'py, PyAny>>,
     /// Whether to use a cache of short strings to accelerate python string construction
     cache_str: StringCacheMode,
-    /// Whether to allow validation of partial objects
-    pub allow_partial: bool,
 }
 
 impl<'a, 'py> Extra<'a, 'py> {
@@ -640,7 +637,6 @@ impl<'a, 'py> Extra<'a, 'py> {
         self_instance: Option<&'a Bound<'py, PyAny>>,
         input_type: InputType,
         cache_str: StringCacheMode,
-        allow_partial: bool,
     ) -> Self {
         Extra {
             input_type,
@@ -650,7 +646,6 @@ impl<'a, 'py> Extra<'a, 'py> {
             context,
             self_instance,
             cache_str,
-            allow_partial,
         }
     }
 }
@@ -665,7 +660,6 @@ impl Extra<'_, '_> {
             context: self.context,
             self_instance: self.self_instance,
             cache_str: self.cache_str,
-            allow_partial: self.allow_partial,
         }
     }
 }