Remaining work

pydantic · Feb 27, 2025 · 1555034 · 1555034
1 parent 84a574c
commit 1555034
Show file tree

Hide file tree

Showing 4 changed files with 58 additions and 9 deletions.
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
@@ -267,6 +267,7 @@ pub trait ValidatedList<'py> {
 pub trait ValidatedTuple<'py> {
     type Item: BorrowInput<'py>;
     fn len(&self) -> Option<usize>;
+    fn try_for_each(self, f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()>;
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R>;
 }
 
@@ -315,6 +316,9 @@ impl<'py> ValidatedTuple<'py> for Never {
     fn len(&self) -> Option<usize> {
         unreachable!()
     }
+    fn try_for_each(self, _f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()> {
+        unreachable!()
+    }
     fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         unreachable!()
     }

diff --git a/src/input/input_json.rs b/src/input/input_json.rs
@@ -581,6 +581,12 @@ impl<'a, 'data> ValidatedTuple<'_> for &'a JsonArray<'data> {
     fn len(&self) -> Option<usize> {
         Some(SmallVec::len(self))
     }
+    fn try_for_each(self, mut f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()> {
+        for item in self.iter() {
+            f(Ok(item))?;
+        }
+        Ok(())
+    }
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         Ok(consumer.consume_iterator(self.iter().map(Ok)))
     }

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
@@ -925,7 +925,15 @@ impl<'py> PySequenceIterable<'_, 'py> {
             PySequenceIterable::Iterator(iter) => iter.len().ok(),
         }
     }
-
+    fn generic_try_for_each(self, f: impl FnMut(PyResult<Bound<'py, PyAny>>) -> ValResult<()>) -> ValResult<()> {
+        match self {
+            PySequenceIterable::List(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::Tuple(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::Set(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::FrozenSet(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::Iterator(mut iter) => iter.try_for_each(f),
+        }
+    }
     fn generic_iterate<R>(
         self,
         consumer: impl ConsumeIterator<PyResult<Bound<'py, PyAny>>, Output = R>,
@@ -961,6 +969,9 @@ impl<'py> ValidatedTuple<'py> for PySequenceIterable<'_, 'py> {
     fn len(&self) -> Option<usize> {
         self.generic_len()
     }
+    fn try_for_each(self, f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()> {
+        self.generic_try_for_each(f)
+    }
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         self.generic_iterate(consumer)
     }

diff --git a/src/validators/arguments_v3.rs b/src/validators/arguments_v3.rs
@@ -10,7 +10,9 @@ use pyo3::IntoPyObjectExt;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidatedDict, ValidationMatch};
+use crate::input::{
+    Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidatedDict, ValidatedTuple, ValidationMatch,
+};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 
@@ -209,11 +211,29 @@ impl ArgumentsV3Validator {
                             Err(err) => return Err(err),
                         }
                     }
-                    // ParameterMode::VarArgs => match dict_value.validate_tuple() {
-                    //     Ok(iterable) => for value in iterable,
-                    //     Err(err) => return Err(err),
-                    // },
-                    ParameterMode::VarArgs => todo!(),
+                    ParameterMode::VarArgs => match dict_value.borrow_input().validate_tuple(false) {
+                        Ok(tuple) => {
+                            tuple.unpack(state).try_for_each(|v| {
+                                match parameter.validator.validate(py, v.unwrap().borrow_input(), state) {
+                                    Ok(tuple_value) => {
+                                        output_args.push(tuple_value);
+                                        return Ok(());
+                                    }
+                                    Err(ValError::LineErrors(line_errors)) => {
+                                        errors.extend(line_errors.into_iter().map(|err| {
+                                            lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)
+                                        }));
+                                        return Ok(());
+                                    }
+                                    Err(err) => return Err(err),
+                                }
+                            })?;
+                        }
+                        Err(_) => {
+                            let val_error = ValLineError::new(ErrorTypeDefaults::TupleType, dict_value.borrow_input());
+                            errors.push(lookup_path.apply_error_loc(val_error, self.loc_by_alias, &parameter.name));
+                        }
+                    },
                     ParameterMode::KeywordOnly => {
                         match parameter.validator.validate(py, dict_value.borrow_input(), state) {
                             Ok(value) => {
@@ -240,6 +260,7 @@ impl ArgumentsV3Validator {
                                         for err in line_errors {
                                             errors.push(
                                                 err.with_outer_location(dict_key.clone())
+                                                    .with_outer_location(&parameter.name)
                                                     .with_type(ErrorTypeDefaults::InvalidKey),
                                             );
                                         }
@@ -252,14 +273,21 @@ impl ArgumentsV3Validator {
                                     Ok(value) => output_kwargs.set_item(dict_key, value)?,
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(line_errors.into_iter().map(|err| {
-                                            lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)
+                                            lookup_path.apply_error_loc(
+                                                err.with_outer_location(dict_key.clone()),
+                                                self.loc_by_alias,
+                                                &parameter.name,
+                                            )
                                         }));
                                     }
                                     Err(err) => return Err(err),
                                 }
                             }
                         }
-                        None => todo!(),
+                        None => {
+                            let val_error = ValLineError::new(ErrorTypeDefaults::DictType, dict_value);
+                            errors.push(lookup_path.apply_error_loc(val_error, self.loc_by_alias, &parameter.name));
+                        }
                     },
                     ParameterMode::VarKwargsUnpackedTypedDict => {
                         let kwargs_dict = dict_value