support pass through on functions

Author: samuelcolvin

pydantic_core/_pydantic_core.pyi

@@ -38,26 +38,26 @@ class SchemaValidator:
     def title(self) -> str: ...
     def __init__(self, schema: CoreSchema, config: 'CoreConfig | None' = None) -> None: ...
     def validate_python(
-        self, input: Any, *, strict: 'bool | None' = None, context: Any = None, in_init: bool = False
+        self, input: Any, *, strict: 'bool | None' = None, context: Any = None, init_mode: bool = False
     ) -> Any: ...
     def isinstance_python(
-        self, input: Any, *, strict: 'bool | None' = None, context: Any = None, in_init: bool = False
+        self, input: Any, *, strict: 'bool | None' = None, context: Any = None, init_mode: bool = False
     ) -> bool: ...
     def validate_json(
         self,
         input: 'str | bytes | bytearray',
         *,
         strict: 'bool | None' = None,
         context: Any = None,
-        in_init: bool = False,
+        init_mode: bool = False,
     ) -> Any: ...
     def isinstance_json(
         self,
         input: 'str | bytes | bytearray',
         *,
         strict: 'bool | None' = None,
         context: Any = None,
-        in_init: bool = False,
+        init_mode: bool = False,
     ) -> bool: ...
     def validate_assignment(
         self, field: str, input: Any, data: 'dict[str, Any]', strict: 'bool | None' = None, context: Any = None

src/validators/function.rs

@@ -110,6 +110,24 @@ impl Validator for FunctionBeforeValidator {
             .validate(py, value.into_ref(py), extra, slots, recursion_guard)
     }
 
+    fn validate_init<'s, 'data>(
+        &'s self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        extra: &Extra,
+        slots: &'data [CombinedValidator],
+        recursion_guard: &'s mut RecursionGuard,
+    ) -> ValResult<'data, PyObject> {
+        let info = ValidationInfo::new(py, extra, &self.config);
+        let value = self
+            .func
+            .call1(py, (input.to_object(py), info))
+            .map_err(|e| convert_err(py, e, input))?;
+
+        self.validator
+            .validate_init(py, value.into_ref(py), extra, slots, recursion_guard)
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }
@@ -148,6 +166,19 @@ impl Validator for FunctionAfterValidator {
         self.func.call1(py, (v, info)).map_err(|e| convert_err(py, e, input))
     }
 
+    fn validate_init<'s, 'data>(
+        &'s self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        extra: &Extra,
+        slots: &'data [CombinedValidator],
+        recursion_guard: &'s mut RecursionGuard,
+    ) -> ValResult<'data, PyObject> {
+        let v = self.validator.validate_init(py, input, extra, slots, recursion_guard)?;
+        let info = ValidationInfo::new(py, extra, &self.config);
+        self.func.call1(py, (v, info)).map_err(|e| convert_err(py, e, input))
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }
@@ -227,7 +258,40 @@ impl Validator for FunctionWrapValidator {
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         let call_next_validator = ValidatorCallable {
-            validator: InternalValidator::new(py, "ValidatorCallable", &self.validator, slots, extra, recursion_guard),
+            validator: InternalValidator::new(
+                py,
+                "ValidatorCallable",
+                &self.validator,
+                slots,
+                extra,
+                recursion_guard,
+                false,
+            ),
+        };
+        let info = ValidationInfo::new(py, extra, &self.config);
+        self.func
+            .call1(py, (input.to_object(py), call_next_validator, info))
+            .map_err(|e| convert_err(py, e, input))
+    }
+
+    fn validate_init<'s, 'data>(
+        &'s self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        extra: &Extra,
+        slots: &'data [CombinedValidator],
+        recursion_guard: &'s mut RecursionGuard,
+    ) -> ValResult<'data, PyObject> {
+        let call_next_validator = ValidatorCallable {
+            validator: InternalValidator::new(
+                py,
+                "ValidatorCallable",
+                &self.validator,
+                slots,
+                extra,
+                recursion_guard,
+                true,
+            ),
         };
         let info = ValidationInfo::new(py, extra, &self.config, self.is_field_validator)?;
         self.func

src/validators/generator.rs

@@ -57,7 +57,7 @@ impl Validator for GeneratorValidator {
         let validator = self
             .item_validator
             .as_ref()
-            .map(|v| InternalValidator::new(py, "ValidatorIterator", v, slots, extra, recursion_guard));
+            .map(|v| InternalValidator::new(py, "ValidatorIterator", v, slots, extra, recursion_guard, false));
 
         let v_iterator = ValidatorIterator {
             iterator,
@@ -196,6 +196,7 @@ pub struct InternalValidator {
     strict: Option<bool>,
     context: Option<PyObject>,
     recursion_guard: RecursionGuard,
+    init_mode: bool,
 }
 
 impl fmt::Debug for InternalValidator {
@@ -212,6 +213,7 @@ impl InternalValidator {
         slots: &[CombinedValidator],
         extra: &Extra,
         recursion_guard: &RecursionGuard,
+        init_mode: bool,
     ) -> Self {
         Self {
             name: name.to_string(),
@@ -222,6 +224,7 @@ impl InternalValidator {
             strict: extra.strict,
             context: extra.context.map(|d| d.into_py(py)),
             recursion_guard: recursion_guard.clone(),
+            init_mode,
         }
     }
 
@@ -241,8 +244,13 @@ impl InternalValidator {
             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)
-            .map_err(|e| ValidationError::from_val_error(py, self.name.to_object(py), e, outer_location))
+        let r = if self.init_mode {
+            self.validator
+                .validate_init(py, input, &extra, &self.slots, &mut self.recursion_guard)
+        } else {
+            self.validator
+                .validate(py, input, &extra, &self.slots, &mut self.recursion_guard)
+        };
+        r.map_err(|e| ValidationError::from_val_error(py, self.name.to_object(py), e, outer_location))
     }
 }

src/validators/mod.rs

@@ -97,65 +97,65 @@ impl SchemaValidator {
         Ok((cls, args).into_py(py))
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, in_init=false))]
+    #[pyo3(signature = (input, *, strict=None, context=None, init_mode=false))]
     pub fn validate_python(
         &self,
         py: Python,
         input: &PyAny,
         strict: Option<bool>,
         context: Option<&PyAny>,
-        in_init: bool,
+        init_mode: bool,
     ) -> PyResult<PyObject> {
-        let r = self._validate(py, input, strict, context, in_init);
+        let r = self._validate(py, input, strict, context, init_mode);
         r.map_err(|e| self.prepare_validation_err(py, e))
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, in_init=false))]
+    #[pyo3(signature = (input, *, strict=None, context=None, init_mode=false))]
     pub fn isinstance_python(
         &self,
         py: Python,
         input: &PyAny,
         strict: Option<bool>,
         context: Option<&PyAny>,
-        in_init: bool,
+        init_mode: bool,
     ) -> PyResult<bool> {
-        match self._validate(py, input, strict, context, in_init) {
+        match self._validate(py, input, strict, context, init_mode) {
             Ok(_) => Ok(true),
             Err(ValError::InternalErr(err)) => Err(err),
             Err(ValError::Omit) => Err(ValidationError::omit_error()),
             Err(ValError::LineErrors(_)) => Ok(false),
         }
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, in_init=false))]
+    #[pyo3(signature = (input, *, strict=None, context=None, init_mode=false))]
     pub fn validate_json(
         &self,
         py: Python,
         input: &PyAny,
         strict: Option<bool>,
         context: Option<&PyAny>,
-        in_init: bool,
+        init_mode: bool,
     ) -> PyResult<PyObject> {
         match input.parse_json() {
             Ok(input) => {
-                let r = self._validate(py, &input, strict, context, in_init);
+                let r = self._validate(py, &input, strict, context, init_mode);
                 r.map_err(|e| self.prepare_validation_err(py, e))
             }
             Err(err) => Err(self.prepare_validation_err(py, err)),
         }
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, in_init=false))]
+    #[pyo3(signature = (input, *, strict=None, context=None, init_mode=false))]
     pub fn isinstance_json(
         &self,
         py: Python,
         input: &PyAny,
         strict: Option<bool>,
         context: Option<&PyAny>,
-        in_init: bool,
+        init_mode: bool,
     ) -> PyResult<bool> {
         match input.parse_json() {
-            Ok(input) => match self._validate(py, &input, strict, context, in_init) {
+            Ok(input) => match self._validate(py, &input, strict, context, init_mode) {
                 Ok(_) => Ok(true),
                 Err(ValError::InternalErr(err)) => Err(err),
                 Err(ValError::Omit) => Err(ValidationError::omit_error()),
@@ -220,12 +220,12 @@ impl SchemaValidator {
         input: &'data impl Input<'data>,
         strict: Option<bool>,
         context: Option<&'data PyAny>,
-        in_init: bool,
+        init_mode: bool,
     ) -> ValResult<'data, PyObject>
     where
         's: 'data,
     {
-        if in_init {
+        if init_mode {
             self.validator.validate_init(
                 py,
                 input,

tests/test_isinstance.py

@@ -11,8 +11,8 @@ def test_isinstance():
     assert v.isinstance_python(123) is True
     assert v.validate_python('123') == 123
     assert v.isinstance_python('123') is True
-    assert v.validate_python('123', in_init=True) == 123
-    assert v.isinstance_python('123', in_init=True) is True
+    assert v.validate_python('123', init_mode=True) == 123
+    assert v.isinstance_python('123', init_mode=True) is True
 
     with pytest.raises(ValidationError, match='Input should be a valid integer'):
         v.validate_python('foo')

tests/validators/test_model.py

@@ -638,74 +638,3 @@ def call_me_baby(self, context, **kwargs):
     assert m.field_b == 12
     assert m.__fields_set__ == {'field_a'}
     assert m.__dict__ == {'field_a': 'testtest', 'field_b': 12}
-
-
-def test_model_init():
-    class MyModel:
-        # this is not required, but it avoids `__fields_set__` being included in `__dict__`
-        __slots__ = '__dict__', '__fields_set__'
-        field_a: str
-        field_b: int
-
-    v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'typed-dict',
-                'return_fields_set': True,
-                'fields': {'field_a': {'schema': {'type': 'str'}}, 'field_b': {'schema': {'type': 'int'}}},
-            },
-        }
-    )
-    m = v.validate_python({'field_a': 'test', 'field_b': 12})
-    assert isinstance(m, MyModel)
-    assert m.field_a == 'test'
-    assert m.field_b == 12
-    d, fields_set = v.validate_python({'field_a': 'test', 'field_b': 12}, in_init=True)
-    assert d == {'field_a': 'test', 'field_b': 12}
-    assert fields_set == {'field_a', 'field_b'}
-
-
-def test_model_init_nested():
-    class MyModel:
-        # this is not required, but it avoids `__fields_set__` being included in `__dict__`
-        __slots__ = '__dict__', '__fields_set__'
-
-    v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'typed-dict',
-                'return_fields_set': True,
-                'fields': {
-                    'field_a': {'schema': {'type': 'str'}},
-                    'field_b': {
-                        'schema': {
-                            'type': 'model',
-                            'cls': MyModel,
-                            'schema': {
-                                'type': 'typed-dict',
-                                'return_fields_set': True,
-                                'fields': {'x_a': {'schema': {'type': 'str'}}, 'x_b': {'schema': {'type': 'int'}}},
-                            },
-                        }
-                    },
-                },
-            },
-        }
-    )
-    m = v.validate_python({'field_a': 'test', 'field_b': {'x_a': 'foo', 'x_b': 12}})
-    assert isinstance(m, MyModel)
-    assert m.field_a == 'test'
-    assert isinstance(m.field_b, MyModel)
-    assert m.field_b.x_a == 'foo'
-    assert m.field_b.x_b == 12
-    d, fields_set = v.validate_python({'field_a': 'test', 'field_b': {'x_a': 'foo', 'x_b': 12}}, in_init=True)
-    assert d['field_a'] == 'test'
-    assert isinstance(d['field_b'], MyModel)
-    assert d['field_b'].x_a == 'foo'
-    assert d['field_b'].x_b == 12
-
-    assert fields_set == {'field_a', 'field_b'}