Add field_name to ValidatorInfo (#439)

* Add field to ValidatorInfo

* minimize changes

* cleanup

* pr feedback

* use field_name

* fix types

* Fix defaults

* wip, can't get self schema to work

* handle edge cases

* update docstrings

* fix docstrings

* fix tests

* don't use a pipe

* replace double with single quotes

* make type first field and remove Required[]

* rename model_field_function_plain_schema to method_plain_schema

* move logic into destructure_function_schema

* implement pr feedback on getters

* rename Extra.field to Extra.field_we_are_currently_assigning_to

* rename field_we_are_currently_assigning_to to assignee_field

* rename methods

* fix logic

* rename type

* rename callback -> function, fix error message

* rename callback -> function, more

* tests for info.data

---------

Co-authored-by: Samuel Colvin <[email protected]>

Author: adriangb

pydantic_core/core_schema.py

@@ -1,7 +1,7 @@
-use pyo3::exceptions::{PyAssertionError, PyTypeError, PyValueError};
+use pyo3::exceptions::{PyAssertionError, PyAttributeError, PyRuntimeError, PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict};
+use pyo3::types::{PyAny, PyDict, PyString};
 
 use crate::build_tools::{function_name, py_err, SchemaDict};
 use crate::errors::{
@@ -16,6 +16,18 @@ use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Ex
 
 pub struct FunctionBuilder;
 
+fn destructure_function_schema(schema: &PyDict) -> PyResult<(bool, &PyAny)> {
+    let func_dict: &PyDict = schema.get_as_req(intern!(schema.py(), "function"))?;
+    let function: &PyAny = func_dict.get_as_req(intern!(schema.py(), "function"))?;
+    let func_type: &str = func_dict.get_as_req(intern!(schema.py(), "type"))?;
+    let is_field_validator = match func_type {
+        "field" => true,
+        "general" => false,
+        _ => unreachable!(),
+    };
+    Ok((is_field_validator, function))
+}
+
 impl BuildValidator for FunctionBuilder {
     const EXPECTED_TYPE: &'static str = "function";
 
@@ -45,7 +57,7 @@ macro_rules! impl_build {
             ) -> PyResult<CombinedValidator> {
                 let py = schema.py();
                 let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, build_context)?;
-                let function = schema.get_as_req::<&PyAny>(intern!(py, "function"))?;
+                let (is_field_validator, function) = destructure_function_schema(schema)?;
                 let name = format!(
                     "{}[{}(), {}]",
                     $name,
@@ -60,6 +72,7 @@ macro_rules! impl_build {
                         None => py.None(),
                     },
                     name,
+                    is_field_validator,
                 }
                 .into())
             }
@@ -73,6 +86,7 @@ pub struct FunctionBeforeValidator {
     func: PyObject,
     config: PyObject,
     name: String,
+    is_field_validator: bool,
 }
 
 impl_build!(FunctionBeforeValidator, "function-before");
@@ -86,7 +100,7 @@ impl Validator for FunctionBeforeValidator {
         slots: &'data [CombinedValidator],
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let info = ValidationInfo::new(py, extra, &self.config);
+        let info = ValidationInfo::new(py, extra, &self.config, self.is_field_validator)?;
         let value = self
             .func
             .call1(py, (input.to_object(py), info))
@@ -115,6 +129,7 @@ pub struct FunctionAfterValidator {
     func: PyObject,
     config: PyObject,
     name: String,
+    is_field_validator: bool,
 }
 
 impl_build!(FunctionAfterValidator, "function-after");
@@ -129,7 +144,7 @@ impl Validator for FunctionAfterValidator {
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let v = self.validator.validate(py, input, extra, slots, recursion_guard)?;
-        let info = ValidationInfo::new(py, extra, &self.config);
+        let info = ValidationInfo::new(py, extra, &self.config, self.is_field_validator)?;
         self.func.call1(py, (v, info)).map_err(|e| convert_err(py, e, input))
     }
 
@@ -151,19 +166,21 @@ pub struct FunctionPlainValidator {
     func: PyObject,
     config: PyObject,
     name: String,
+    is_field_validator: bool,
 }
 
 impl FunctionPlainValidator {
     pub fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let function = schema.get_as_req::<&PyAny>(intern!(py, "function"))?;
+        let (is_field_validator, function) = destructure_function_schema(schema)?;
         Ok(Self {
             func: function.into_py(py),
             config: match config {
                 Some(c) => c.into(),
                 None => py.None(),
             },
             name: format!("function-plain[{}()]", function_name(function)?),
+            is_field_validator,
         }
         .into())
     }
@@ -178,7 +195,7 @@ impl Validator for FunctionPlainValidator {
         _slots: &'data [CombinedValidator],
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let info = ValidationInfo::new(py, extra, &self.config);
+        let info = ValidationInfo::new(py, extra, &self.config, self.is_field_validator)?;
         self.func
             .call1(py, (input.to_object(py), info))
             .map_err(|e| convert_err(py, e, input))
@@ -195,6 +212,7 @@ pub struct FunctionWrapValidator {
     func: PyObject,
     config: PyObject,
     name: String,
+    is_field_validator: bool,
 }
 
 impl_build!(FunctionWrapValidator, "function-wrap");
@@ -211,7 +229,7 @@ impl Validator for FunctionWrapValidator {
         let call_next_validator = ValidatorCallable {
             validator: InternalValidator::new(py, "ValidatorCallable", &self.validator, slots, extra, recursion_guard),
         };
-        let info = ValidationInfo::new(py, extra, &self.config);
+        let info = ValidationInfo::new(py, extra, &self.config, self.is_field_validator)?;
         self.func
             .call1(py, (input.to_object(py), call_next_validator, info))
             .map_err(|e| convert_err(py, e, input))
@@ -300,20 +318,54 @@ pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) ->
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
 pub struct ValidationInfo {
-    #[pyo3(get)]
-    data: Option<Py<PyDict>>,
     #[pyo3(get)]
     config: PyObject,
     #[pyo3(get)]
     context: Option<PyObject>,
+    data: Option<Py<PyDict>>,
+    field_name: Option<String>,
 }
 
 impl ValidationInfo {
-    fn new(py: Python, extra: &Extra, config: &PyObject) -> Self {
-        Self {
-            data: extra.data.map(|v| v.into()),
-            config: config.clone_ref(py),
-            context: extra.context.map(|v| v.into()),
+    fn new(py: Python, extra: &Extra, config: &PyObject, is_field_validator: bool) -> PyResult<Self> {
+        if is_field_validator {
+            match extra.field_name {
+                Some(field_name) => Ok(
+                    Self {
+                        config: config.clone_ref(py),
+                        context: extra.context.map(|v| v.into()),
+                        field_name: Some(field_name.to_string()),
+                        data: extra.data.map(|v| v.into()),
+                    }
+                ),
+                _ => Err(PyRuntimeError::new_err("This validator expected to be run inside the context of a model field but no model field was found")),
+            }
+        } else {
+            Ok(Self {
+                config: config.clone_ref(py),
+                context: extra.context.map(|v| v.into()),
+                field_name: None,
+                data: None,
+            })
+        }
+    }
+}
+
+#[pymethods]
+impl ValidationInfo {
+    #[getter]
+    fn get_data(&self, py: Python) -> PyResult<Py<PyDict>> {
+        match self.data {
+            Some(ref data) => Ok(data.clone_ref(py)),
+            None => Err(PyAttributeError::new_err("No attribute named 'data'")),
+        }
+    }
+
+    #[getter]
+    fn get_field_name<'py>(&self, py: Python<'py>) -> PyResult<&'py PyString> {
+        match self.field_name {
+            Some(ref field_name) => Ok(PyString::new(py, field_name)),
+            None => Err(PyAttributeError::new_err("No attribute named 'field_name'")),
         }
     }
 }

src/validators/function.rs

@@ -218,7 +218,7 @@ impl InternalValidator {
             validator: validator.clone(),
             slots: slots.to_vec(),
             data: extra.data.map(|d| d.into_py(py)),
-            field: extra.field.map(|f| f.to_string()),
+            field: extra.assignee_field.map(|f| f.to_string()),
             strict: extra.strict,
             context: extra.context.map(|d| d.into_py(py)),
             recursion_guard: recursion_guard.clone(),
@@ -236,9 +236,10 @@ impl InternalValidator {
     {
         let extra = Extra {
             data: self.data.as_ref().map(|data| data.as_ref(py)),
-            field: self.field.as_deref(),
+            assignee_field: self.field.as_deref(),
             strict: self.strict,
             context: self.context.as_ref().map(|data| data.as_ref(py)),
+            field_name: None,
         };
         self.validator
             .validate(py, input, &extra, &self.slots, &mut self.recursion_guard)

src/validators/generator.rs

@@ -194,9 +194,10 @@ impl SchemaValidator {
     ) -> PyResult<PyObject> {
         let extra = Extra {
             data: Some(data),
-            field: Some(field.as_str()),
+            assignee_field: Some(field.as_str()),
             strict,
             context,
+            field_name: None,
         };
         let r = self
             .validator
@@ -448,8 +449,11 @@ pub struct Extra<'a> {
     /// This is used as the `data` kwargs to validator functions, it also represents the current model
     /// data when validating assignment
     pub data: Option<&'a PyDict>,
+    /// Represents the fields of the model we are currently validating
+    /// If there is no model this will be None
+    pub field_name: Option<&'a str>,
     /// The field being assigned to when validating assignment
-    pub field: Option<&'a str>,
+    pub assignee_field: Option<&'a str>,
     /// whether we're in strict or lax mode
     pub strict: Option<bool>,
     /// context used in validator functions
@@ -470,9 +474,10 @@ impl<'a> Extra<'a> {
     pub fn as_strict(&self) -> Self {
         Self {
             data: self.data,
-            field: self.field,
+            assignee_field: self.assignee_field,
             strict: Some(true),
             context: self.context,
+            field_name: self.field_name,
         }
     }
 }

src/validators/mod.rs

@@ -162,7 +162,7 @@ impl Validator for TypedDictValidator {
         slots: &'data [CombinedValidator],
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        if let Some(field) = extra.field {
+        if let Some(field) = extra.assignee_field {
             // we're validating assignment, completely different logic
             return self.validate_assignment(py, field, input, extra, slots, recursion_guard);
         }
@@ -183,16 +183,14 @@ impl Validator for TypedDictValidator {
             false => None,
         };
 
-        let extra = Extra {
-            data: Some(output_dict),
-            field: None,
-            strict: extra.strict,
-            context: extra.context,
-        };
-
         macro_rules! process {
             ($dict:ident, $get_method:ident, $iter:ty $(,$kwargs:ident)?) => {{
                 for field in &self.fields {
+                    let extra = Extra {
+                        data: Some(output_dict),
+                        field_name: Some(&field.name),
+                        ..*extra
+                    };
                     let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
                         Ok(v) => v,
                         Err(err) => {
@@ -348,6 +346,11 @@ impl TypedDictValidator {
     where
         'data: 's,
     {
+        let extra = Extra {
+            field_name: Some(field),
+            assignee_field: None,
+            ..*extra
+        };
         // TODO probably we should set location on errors here
         let data = match extra.data {
             Some(data) => data,
@@ -380,12 +383,12 @@ impl TypedDictValidator {
             if field.frozen {
                 Err(ValError::new_with_loc(ErrorType::Frozen, input, field.name.to_string()))
             } else {
-                prepare_result(field.validator.validate(py, input, extra, slots, recursion_guard))
+                prepare_result(field.validator.validate(py, input, &extra, slots, recursion_guard))
             }
         } else if self.check_extra && !self.forbid_extra {
             // this is the "allow" case of extra_behavior
             match self.extra_validator {
-                Some(ref validator) => prepare_result(validator.validate(py, input, extra, slots, recursion_guard)),
+                Some(ref validator) => prepare_result(validator.validate(py, input, &extra, slots, recursion_guard)),
                 None => prepare_tuple(input.to_object(py)),
             }
         } else {

src/validators/typed_dict.rs

@@ -110,27 +110,33 @@ def wrap_function(input_value, validator, info):
                                 'schema': {
                                     'type': 'function',
                                     'mode': 'before',
-                                    'function': append_func,
+                                    'function': {'type': 'general', 'function': append_func},
                                     'schema': {'type': 'str'},
                                 }
                             },
                             'field_after': {
                                 'schema': {
                                     'type': 'function',
                                     'mode': 'after',
-                                    'function': append_func,
+                                    'function': {'type': 'general', 'function': append_func},
                                     'schema': {'type': 'str'},
                                 }
                             },
                             'field_wrap': {
                                 'schema': {
                                     'type': 'function',
                                     'mode': 'wrap',
-                                    'function': wrap_function,
+                                    'function': {'type': 'general', 'function': wrap_function},
                                     'schema': {'type': 'str'},
                                 }
                             },
-                            'field_plain': {'schema': {'type': 'function', 'mode': 'plain', 'function': append_func}},
+                            'field_plain': {
+                                'schema': {
+                                    'type': 'function',
+                                    'mode': 'plain',
+                                    'function': {'type': 'general', 'function': append_func},
+                                }
+                            },
                         },
                     }
                 },