Replace **kwargs with a ValidatorInfo object in validation functions (#423)

Author: adriangb

pydantic_core/core_schema.py

@@ -70,6 +70,19 @@ def __repr__(self) -> str:
         ...
 
 
+class ValidationInfo(Protocol):
+    """
+    Argument passed to validation functions.
+    """
+
+    data: Dict[str, Any]
+    """All of the fields and data being validated for this model."""
+    context: Dict[str, Any]
+    """Current validation context."""
+    config: CoreConfig | None
+    """The CoreConfig that applies to this validation."""
+
+
 ExpectedSerializationTypes = Literal[
     'none',
     'int',
@@ -1430,9 +1443,7 @@ def dict_schema(
 
 
 class ValidatorFunction(Protocol):
-    def __call__(
-        self, __input_value: Any, *, data: Any, config: CoreConfig | None, context: Any, **future_kwargs: Any
-    ) -> Any:  # pragma: no cover
+    def __call__(self, __input_value: Any, __info: ValidationInfo) -> Any:  # pragma: no cover
         ...
 
 
@@ -1461,7 +1472,7 @@ def function_before_schema(
     from typing import Any
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: Any, **kwargs) -> str:
+    def fn(v: Any, info: core_schema.ValidationInfo) -> str:
         v_str = str(v)
         assert 'hello' in v_str
         return v_str + 'world'
@@ -1503,7 +1514,7 @@ def function_after_schema(
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: str, **kwargs) -> str:
+    def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert 'hello' in v
         return v + 'world'
 
@@ -1537,14 +1548,7 @@ def __call__(self, input_value: Any, outer_location: str | int | None = None) ->
 
 class WrapValidatorFunction(Protocol):
     def __call__(
-        self,
-        __input_value: Any,
-        *,
-        validator: CallableValidator,
-        data: Any,
-        config: CoreConfig | None,
-        context: Any,
-        **future_kwargs: Any,
+        self, __input_value: Any, __validator: CallableValidator, __info: ValidationInfo
     ) -> Any:  # pragma: no cover
         ...
 
@@ -1575,7 +1579,7 @@ def function_wrap_schema(
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: str, *, validator, **kwargs) -> str:
+    def fn(v: str, validator: core_schema.CallableValidator, info: core_schema.ValidationInfo) -> str:
         return validator(input_value=v) + 'world'
 
     schema = core_schema.function_wrap_schema(function=fn, schema=core_schema.str_schema())
@@ -1619,7 +1623,7 @@ def function_plain_schema(
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: str, **kwargs) -> str:
+    def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert 'hello' in v
         return v + 'world'
 
@@ -1912,7 +1916,7 @@ def chain_schema(
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: str, **kwargs) -> str:
+    def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert 'hello' in v
         return v + ' world'
 
@@ -1956,7 +1960,7 @@ def lax_or_strict_schema(
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: str, **kwargs) -> str:
+    def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert 'hello' in v
         return v + ' world'
 

src/build_tools.rs

@@ -203,13 +203,6 @@ pub fn function_name(f: &PyAny) -> PyResult<String> {
     }
 }
 
-macro_rules! kwargs {
-    ($py:ident, $($k:ident: $v:expr),* $(,)?) => {{
-        Some(pyo3::types::IntoPyDict::into_py_dict([$((stringify!($k), $v.into_py($py)),)*], $py).into())
-    }};
-}
-pub(crate) use kwargs;
-
 pub fn safe_repr(v: &PyAny) -> Cow<str> {
     match v.repr() {
         Ok(r) => r.to_string_lossy(),

src/validators/function.rs

@@ -3,7 +3,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict};
 
-use crate::build_tools::{function_name, kwargs, py_err, SchemaDict};
+use crate::build_tools::{function_name, py_err, SchemaDict};
 use crate::errors::{
     ErrorType, LocItem, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
 };
@@ -86,10 +86,10 @@ impl Validator for FunctionBeforeValidator {
         slots: &'data [CombinedValidator],
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let kwargs = kwargs!(py, data: extra.data, config: self.config.clone_ref(py), context: extra.context);
+        let info = ValidationInfo::new(extra, &self.config, py);
         let value = self
             .func
-            .call(py, (input.to_object(py),), kwargs)
+            .call1(py, (input.to_object(py), info))
             .map_err(|e| convert_err(py, e, input))?;
 
         self.validator
@@ -129,8 +129,8 @@ impl Validator for FunctionAfterValidator {
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let v = self.validator.validate(py, input, extra, slots, recursion_guard)?;
-        let kwargs = kwargs!(py, data: extra.data, config: self.config.clone_ref(py), context: extra.context);
-        self.func.call(py, (v,), kwargs).map_err(|e| convert_err(py, e, input))
+        let info = ValidationInfo::new(extra, &self.config, py);
+        self.func.call1(py, (v, info)).map_err(|e| convert_err(py, e, input))
     }
 
     fn get_name(&self) -> &str {
@@ -178,9 +178,9 @@ impl Validator for FunctionPlainValidator {
         _slots: &'data [CombinedValidator],
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let kwargs = kwargs!(py, data: extra.data, config: self.config.clone_ref(py), context: extra.context);
+        let info = ValidationInfo::new(extra, &self.config, py);
         self.func
-            .call(py, (input.to_object(py),), kwargs)
+            .call1(py, (input.to_object(py), info))
             .map_err(|e| convert_err(py, e, input))
     }
 
@@ -208,18 +208,12 @@ impl Validator for FunctionWrapValidator {
         slots: &'data [CombinedValidator],
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        let validator_kwarg = ValidatorCallable {
+        let call_next_validator = ValidatorCallable {
             validator: InternalValidator::new(py, "ValidatorCallable", &self.validator, slots, extra, recursion_guard),
         };
-        let kwargs = kwargs!(
-            py,
-            validator: validator_kwarg,
-            data: extra.data,
-            config: self.config.clone_ref(py),
-            context: extra.context,
-        );
+        let info = ValidationInfo::new(extra, &self.config, py);
         self.func
-            .call(py, (input.to_object(py),), kwargs)
+            .call1(py, (input.to_object(py), call_next_validator, info))
             .map_err(|e| convert_err(py, e, input))
     }
 
@@ -303,3 +297,23 @@ pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) ->
         ValError::InternalErr(err)
     }
 }
+
+#[pyclass(module = "pydantic_core._pydantic_core")]
+pub struct ValidationInfo {
+    #[pyo3(get)]
+    data: Option<Py<PyDict>>,
+    #[pyo3(get)]
+    config: PyObject,
+    #[pyo3(get)]
+    context: Option<PyObject>,
+}
+
+impl ValidationInfo {
+    fn new(extra: &Extra, config: &PyObject, py: Python) -> Self {
+        ValidationInfo {
+            data: extra.data.map(|v| v.into()),
+            config: config.clone_ref(py),
+            context: extra.context.map(|v| v.into()),
+        }
+    }
+}

tests/benchmarks/complete_schema.py

@@ -3,10 +3,10 @@ class MyModel:
         # __slots__ is not required, but it avoids __fields_set__ falling into __dict__
         __slots__ = '__dict__', '__fields_set__'
 
-    def append_func(input_value, **kwargs):
+    def append_func(input_value, info):
         return f'{input_value} Changed'
 
-    def wrap_function(input_value, *, validator, **kwargs):
+    def wrap_function(input_value, validator, info):
         return f'Input {validator(input_value)} Changed'
 
     return {

tests/benchmarks/test_micro_benchmarks.py

@@ -907,7 +907,7 @@ def validate_with_expected_error():
 
 @pytest.mark.benchmark(group='raise-error')
 def test_dont_raise_error(benchmark):
-    def f(input_value, **kwargs):
+    def f(input_value, info):
         return input_value
 
     v = SchemaValidator({'type': 'function', 'mode': 'plain', 'function': f})
@@ -919,7 +919,7 @@ def t():
 
 @pytest.mark.benchmark(group='raise-error')
 def test_raise_error_value_error(benchmark):
-    def f(input_value, **kwargs):
+    def f(input_value, info):
         raise ValueError('this is a custom error')
 
     v = SchemaValidator({'type': 'function', 'mode': 'plain', 'function': f})
@@ -936,7 +936,7 @@ def t():
 
 @pytest.mark.benchmark(group='raise-error')
 def test_raise_error_custom(benchmark):
-    def f(input_value, **kwargs):
+    def f(input_value, info):
         raise PydanticCustomError('my_error', 'this is a custom error {foo}', {'foo': 'FOOBAR'})
 
     v = SchemaValidator({'type': 'function', 'mode': 'plain', 'function': f})
@@ -1033,10 +1033,7 @@ def test_chain_list(benchmark):
     validator = SchemaValidator(
         {
             'type': 'chain',
-            'steps': [
-                {'type': 'str'},
-                {'type': 'function', 'mode': 'plain', 'function': lambda v, **kwargs: Decimal(v)},
-            ],
+            'steps': [{'type': 'str'}, {'type': 'function', 'mode': 'plain', 'function': lambda v, info: Decimal(v)}],
         }
     )
     assert validator.validate_python('42.42') == Decimal('42.42')
@@ -1047,7 +1044,7 @@ def test_chain_list(benchmark):
 @pytest.mark.benchmark(group='chain')
 def test_chain_function(benchmark):
     validator = SchemaValidator(
-        {'type': 'function', 'mode': 'after', 'schema': {'type': 'str'}, 'function': lambda v, **kwargs: Decimal(v)}
+        {'type': 'function', 'mode': 'after', 'schema': {'type': 'str'}, 'function': lambda v, info: Decimal(v)}
     )
     assert validator.validate_python('42.42') == Decimal('42.42')
 
@@ -1061,8 +1058,8 @@ def test_chain_two_functions(benchmark):
             'type': 'chain',
             'steps': [
                 {'type': 'str'},
-                {'type': 'function', 'mode': 'plain', 'function': lambda v, **kwargs: Decimal(v)},
-                {'type': 'function', 'mode': 'plain', 'function': lambda v, **kwargs: v * 2},
+                {'type': 'function', 'mode': 'plain', 'function': lambda v, info: Decimal(v)},
+                {'type': 'function', 'mode': 'plain', 'function': lambda v, info: v * 2},
             ],
         }
     )
@@ -1080,10 +1077,10 @@ def test_chain_nested_functions(benchmark):
                 'type': 'function',
                 'schema': {'type': 'str'},
                 'mode': 'after',
-                'function': lambda v, **kwargs: Decimal(v),
+                'function': lambda v, info: Decimal(v),
             },
             'mode': 'after',
-            'function': lambda v, **kwargs: v * 2,
+            'function': lambda v, info: v * 2,
         }
     )
     assert validator.validate_python('42.42') == Decimal('84.84')
@@ -1096,7 +1093,7 @@ def validate_yield(iterable, validator):
         yield validator(item)
 
 
-def generator_gen_python(v, *, validator, **_kwargs):
+def generator_gen_python(v, validator, info):
     try:
         iterable = iter(v)
     except TypeError:

tests/serializers/test_other.py

@@ -16,20 +16,20 @@ def test_chain():
 
 
 def test_function_plain():
-    s = SchemaSerializer(core_schema.function_plain_schema(lambda v, **kwargs: v + 1))
+    s = SchemaSerializer(core_schema.function_plain_schema(lambda v, info: v + 1))
     # can't infer the type from plain function validators
     # insert_assert(plain_repr(s))
     assert plain_repr(s) == 'SchemaSerializer(serializer=Any(AnySerializer),slots=[])'
 
 
 def test_function_before():
-    s = SchemaSerializer(core_schema.function_before_schema(lambda v, **kwargs: v + 1, core_schema.int_schema()))
+    s = SchemaSerializer(core_schema.function_before_schema(lambda v, info: v + 1, core_schema.int_schema()))
     # insert_assert(plain_repr(s))
     assert plain_repr(s) == 'SchemaSerializer(serializer=Int(IntSerializer),slots=[])'
 
 
 def test_function_after():
-    s = SchemaSerializer(core_schema.function_after_schema(core_schema.int_schema(), lambda v, **kwargs: v + 1))
+    s = SchemaSerializer(core_schema.function_after_schema(core_schema.int_schema(), lambda v, info: v + 1))
     # insert_assert(plain_repr(s))
     assert plain_repr(s) == 'SchemaSerializer(serializer=Int(IntSerializer),slots=[])'