use ValidationState to propagate exactness

pydantic · Aug 14, 2023 · 8b22d55 · 8b22d55
1 parent 87b4789
commit 8b22d55
Show file tree

Hide file tree

Showing 43 changed files with 783 additions and 792 deletions.
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
@@ -22,9 +22,8 @@ use pyo3::PyTypeInfo;
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ValError, ValLineError, ValResult};
-use crate::recursion_guard::RecursionGuard;
 use crate::tools::py_err;
-use crate::validators::{CombinedValidator, Extra, Validator};
+use crate::validators::{CombinedValidator, ValidationState, Validator};
 
 use super::parse_json::{JsonArray, JsonInput, JsonObject};
 use super::{py_error_on_minusone, Input};
@@ -157,15 +156,14 @@ fn validate_iter_to_vec<'a, 's>(
     capacity: usize,
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
     validator: &'s CombinedValidator,
-    extra: &Extra,
+    state: &mut ValidationState,
     definitions: &'a [CombinedValidator],
-    recursion_guard: &'s mut RecursionGuard,
 ) -> ValResult<'a, Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, max_length_check.input, index))?;
-        match validator.validate(py, item, extra, definitions, recursion_guard) {
+        match validator.validate(py, item, state, definitions) {
             Ok(item) => {
                 max_length_check.incr()?;
                 output.push(item);
@@ -226,14 +224,13 @@ fn validate_iter_to_set<'a, 's>(
     field_type: &'static str,
     max_length: Option<usize>,
     validator: &'s CombinedValidator,
-    extra: &Extra,
+    state: &mut ValidationState,
     definitions: &'a [CombinedValidator],
-    recursion_guard: &'s mut RecursionGuard,
 ) -> ValResult<'a, ()> {
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
-        match validator.validate(py, item, extra, definitions, recursion_guard) {
+        match validator.validate(py, item, state, definitions) {
             Ok(item) => {
                 set.build_add(item)?;
                 if let Some(max_length) = max_length {
@@ -315,9 +312,8 @@ impl<'a> GenericIterable<'a> {
         max_length: Option<usize>,
         field_type: &'static str,
         validator: &'s CombinedValidator,
-        extra: &Extra,
+        state: &mut ValidationState,
         definitions: &'a [CombinedValidator],
-        recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'a, Vec<PyObject>> {
         let capacity = self
             .generic_len()
@@ -332,9 +328,8 @@ impl<'a> GenericIterable<'a> {
                     capacity,
                     max_length_check,
                     validator,
-                    extra,
+                    state,
                     definitions,
-                    recursion_guard,
                 )
             };
         }
@@ -360,9 +355,8 @@ impl<'a> GenericIterable<'a> {
         max_length: Option<usize>,
         field_type: &'static str,
         validator: &'s CombinedValidator,
-        extra: &Extra,
+        state: &mut ValidationState,
         definitions: &'a [CombinedValidator],
-        recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'a, ()> {
         macro_rules! validate_set {
             ($iter:expr) => {
@@ -374,9 +368,8 @@ impl<'a> GenericIterable<'a> {
                     field_type,
                     max_length,
                     validator,
-                    extra,
+                    state,
                     definitions,
-                    recursion_guard,
                 )
             };
         }

diff --git a/src/validators/any.rs b/src/validators/any.rs
@@ -4,9 +4,10 @@ use pyo3::types::PyDict;
 use crate::errors::ValResult;
 use crate::input::Input;
 
-use crate::recursion_guard::RecursionGuard;
-
-use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::{
+    validation_state::{Exactness, ValidationState},
+    BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Validator,
+};
 
 /// This might seem useless, but it's useful in DictValidator to avoid Option<Validator> a lot
 #[derive(Debug, Clone)]
@@ -31,11 +32,10 @@ impl Validator for AnyValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        _extra: &Extra,
+        state: &mut ValidationState,
         _definitions: &'data Definitions<CombinedValidator>,
-        _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        // Ok(input.clone().into_py(py))
+        state.merge_exactness(Exactness::Lax);
         Ok(input.to_object(py))
     }
 

diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
@@ -10,10 +10,10 @@ use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{GenericArguments, Input};
 use crate::lookup_key::LookupKey;
 
-use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
 
-use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::validation_state::ValidationState;
+use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Validator};
 
 #[derive(Debug, Clone)]
 struct Parameter {
@@ -165,9 +165,8 @@ impl Validator for ArgumentsValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         definitions: &'data Definitions<CombinedValidator>,
-        recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let args = input.validate_args()?;
 
@@ -207,7 +206,7 @@ impl Validator for ArgumentsValidator {
                         (Some(pos_value), None) => {
                             match parameter
                                 .validator
-                                .validate(py, pos_value, extra, definitions, recursion_guard)
+                                .validate(py, pos_value, state, definitions)
                             {
                                 Ok(value) => output_args.push(value),
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -219,7 +218,7 @@ impl Validator for ArgumentsValidator {
                         (None, Some((lookup_path, kw_value))) => {
                             match parameter
                                 .validator
-                                .validate(py, kw_value, extra, definitions, recursion_guard)
+                                .validate(py, kw_value, state, definitions)
                             {
                                 Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -231,7 +230,7 @@ impl Validator for ArgumentsValidator {
                             }
                         }
                         (None, None) => {
-                            if let Some(value) = parameter.validator.default_value(py, Some(parameter.name.as_str()), extra, definitions, recursion_guard)? {
+                            if let Some(value) = parameter.validator.default_value(py, Some(parameter.name.as_str()), state, definitions)? {
                                 if let Some(ref kwarg_key) = parameter.kwarg_key {
                                     output_kwargs.set_item(kwarg_key, value)?;
                                 } else {
@@ -261,7 +260,7 @@ impl Validator for ArgumentsValidator {
                     if len > self.positional_params_count {
                         if let Some(ref validator) = self.var_args_validator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
-                                match validator.validate(py, item, extra, definitions, recursion_guard) {
+                                match validator.validate(py, item, state, definitions) {
                                     Ok(value) => output_args.push(value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
@@ -303,7 +302,7 @@ impl Validator for ArgumentsValidator {
                             };
                             if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
                                 match self.var_kwargs_validator {
-                                    Some(ref validator) => match validator.validate(py, value, extra, definitions, recursion_guard) {
+                                    Some(ref validator) => match validator.validate(py, value, state, definitions) {
                                         Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {

diff --git a/src/validators/bool.rs b/src/validators/bool.rs
@@ -5,9 +5,7 @@ use crate::build_tools::is_strict;
 use crate::errors::ValResult;
 use crate::input::Input;
 
-use crate::recursion_guard::RecursionGuard;
-
-use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
 pub struct BoolValidator {
@@ -36,13 +34,14 @@ impl Validator for BoolValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         _definitions: &'data Definitions<CombinedValidator>,
-        _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         // TODO in theory this could be quicker if we used PyBool rather than going to a bool
         // and back again, might be worth profiling?
-        Ok(input.validate_bool(extra.strict.unwrap_or(self.strict))?.into_py(py))
+        let strict = state.strict_or(self.strict);
+        state.set_exactness_unknown();
+        Ok(input.validate_bool(strict)?.into_py(py))
     }
 
     fn different_strict_behavior(

diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
@@ -6,10 +6,9 @@ use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::Input;
 
-use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
 
-use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
 pub struct BytesValidator {
@@ -45,11 +44,11 @@ impl Validator for BytesValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         _definitions: &'data Definitions<CombinedValidator>,
-        _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let either_bytes = input.validate_bytes(extra.strict.unwrap_or(self.strict))?;
+        let either_bytes = input.validate_bytes(state.strict_or(self.strict))?;
+        state.set_exactness_unknown();
         Ok(either_bytes.into_py(py))
     }
 
@@ -84,11 +83,10 @@ impl Validator for BytesConstrainedValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         _definitions: &'data Definitions<CombinedValidator>,
-        _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let either_bytes = input.validate_bytes(extra.strict.unwrap_or(self.strict))?;
+        let either_bytes = input.validate_bytes(state.strict_or(self.strict))?;
         let len = either_bytes.len()?;
 
         if let Some(min_length) = self.min_length {
@@ -114,6 +112,7 @@ impl Validator for BytesConstrainedValidator {
             }
         }
 
+        state.set_exactness_unknown();
         Ok(either_bytes.into_py(py))
     }
 

diff --git a/src/validators/call.rs b/src/validators/call.rs
@@ -6,10 +6,10 @@ use pyo3::types::{PyDict, PyTuple};
 use crate::errors::ValResult;
 use crate::input::Input;
 
-use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
 
-use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::validation_state::ValidationState;
+use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Validator};
 
 #[derive(Debug, Clone)]
 pub struct CallValidator {
@@ -76,13 +76,10 @@ impl Validator for CallValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         definitions: &'data Definitions<CombinedValidator>,
-        recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let args = self
-            .arguments_validator
-            .validate(py, input, extra, definitions, recursion_guard)?;
+        let args = self.arguments_validator.validate(py, input, state, definitions)?;
 
         let return_value = if let Ok((args, kwargs)) = args.extract::<(&PyTuple, &PyDict)>(py) {
             self.function.call(py, args, Some(kwargs))?
@@ -95,7 +92,7 @@ impl Validator for CallValidator {
 
         if let Some(return_validator) = &self.return_validator {
             return_validator
-                .validate(py, return_value.into_ref(py), extra, definitions, recursion_guard)
+                .validate(py, return_value.into_ref(py), state, definitions)
                 .map_err(|e| e.with_outer_location("return".into()))
         } else {
             Ok(return_value.to_object(py))

diff --git a/src/validators/callable.rs b/src/validators/callable.rs
@@ -4,9 +4,8 @@ use pyo3::types::PyDict;
 use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 use crate::input::Input;
 
-use crate::recursion_guard::RecursionGuard;
-
-use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::validation_state::{Exactness, ValidationState};
+use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Validator};
 
 #[derive(Debug, Clone)]
 pub struct CallableValidator;
@@ -30,10 +29,10 @@ impl Validator for CallableValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        _extra: &Extra,
+        state: &mut ValidationState,
         _definitions: &'data Definitions<CombinedValidator>,
-        _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
+        state.merge_exactness(Exactness::Lax);
         match input.callable() {
             true => Ok(input.to_object(py)),
             false => Err(ValError::new(ErrorTypeDefaults::CallableType, input)),

diff --git a/src/validators/chain.rs b/src/validators/chain.rs
@@ -5,10 +5,10 @@ use pyo3::types::{PyDict, PyList};
 use crate::build_tools::py_schema_err;
 use crate::errors::ValResult;
 use crate::input::Input;
-use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
 
-use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::validation_state::ValidationState;
+use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Validator};
 
 #[derive(Debug, Clone)]
 pub struct ChainValidator {
@@ -74,17 +74,14 @@ impl Validator for ChainValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         definitions: &'data Definitions<CombinedValidator>,
-        recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let mut steps_iter = self.steps.iter();
         let first_step = steps_iter.next().unwrap();
-        let value = first_step.validate(py, input, extra, definitions, recursion_guard)?;
+        let value = first_step.validate(py, input, state, definitions)?;
 
-        steps_iter.try_fold(value, |v, step| {
-            step.validate(py, v.into_ref(py), extra, definitions, recursion_guard)
-        })
+        steps_iter.try_fold(value, |v, step| step.validate(py, v.into_ref(py), state, definitions))
     }
 
     fn different_strict_behavior(

diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
@@ -5,10 +5,10 @@ use pyo3::types::PyDict;
 use crate::build_tools::py_schema_err;
 use crate::errors::{ErrorType, PydanticCustomError, PydanticKnownError, ValError, ValResult};
 use crate::input::Input;
-use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
 
-use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
+use super::validation_state::ValidationState;
+use super::{build_validator, BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Validator};
 
 #[derive(Debug, Clone)]
 pub enum CustomError {
@@ -92,12 +92,11 @@ impl Validator for CustomErrorValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        extra: &Extra,
+        state: &mut ValidationState,
         definitions: &'data Definitions<CombinedValidator>,
-        recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         self.validator
-            .validate(py, input, extra, definitions, recursion_guard)
+            .validate(py, input, state, definitions)
             .map_err(|_| self.custom_error.as_val_error(input))
     }