Revert "Add custom_init logic"

This reverts commit f2368a4.

Author: samuelcolvin

pydantic_core/core_schema.py

@@ -2845,7 +2845,6 @@ class ModelSchema(TypedDict, total=False):
     revalidate_instances: Literal['always', 'never', 'subclass-instances']  # default: 'never'
     strict: bool
     frozen: bool
-    custom_init: bool
     config: CoreConfig
     ref: str
     metadata: Any
@@ -2860,7 +2859,6 @@ def model_schema(
     revalidate_instances: Literal['always', 'never', 'subclass-instances'] | None = None,
     strict: bool | None = None,
     frozen: bool | None = None,
-    custom_init: bool | None = None,
     config: CoreConfig | None = None,
     ref: str | None = None,
     metadata: Any = None,
@@ -2900,7 +2898,6 @@ class MyModel:
           should re-validate defaults to config.revalidate_instances, else 'never'
         strict: Whether the model is strict
         frozen: Whether the model is frozen
-        custom_init: Whether the model has a custom init method
         config: The config to use for the model
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
@@ -2914,7 +2911,6 @@ class MyModel:
         revalidate_instances=revalidate_instances,
         strict=strict,
         frozen=frozen,
-        custom_init=custom_init,
         config=config,
         ref=ref,
         metadata=metadata,

src/argument_markers.rs

@@ -60,33 +60,3 @@ impl ArgsKwargs {
         }
     }
 }
-
-pub(crate) const VALIDATED_DATA_KEY: &str = "validated_data";
-
-#[pyclass(module = "pydantic_core._pydantic_core", frozen, get_all, freelist = 100)]
-#[derive(Debug, Clone)]
-pub struct ValidatedData {
-    pub model_dict: PyObject,
-    pub model_extra: PyObject,
-    pub fields_set: PyObject,
-}
-
-impl ValidatedData {
-    pub(crate) fn new(model_dict: &PyAny, model_extra: &PyAny, fields_set: &PyAny) -> Self {
-        Self {
-            model_dict: model_dict.to_object(model_dict.py()),
-            model_extra: model_extra.to_object(model_dict.py()),
-            fields_set: fields_set.to_object(model_dict.py()),
-        }
-    }
-}
-
-#[pymethods]
-impl ValidatedData {
-    fn __repr__(&self, py: Python) -> String {
-        let model_dict = safe_repr(self.model_dict.as_ref(py));
-        let model_extra = safe_repr(self.model_extra.as_ref(py));
-        let fields_set = safe_repr(self.fields_set.as_ref(py));
-        format!("ValidatedData(model_dict={model_dict}, model_extra={model_extra}, fields_set={fields_set})")
-    }
-}

src/input/input_abstract.rs

@@ -3,7 +3,6 @@ use std::fmt;
 use pyo3::prelude::*;
 use pyo3::types::{PyString, PyType};
 
-use crate::argument_markers::ValidatedData;
 use crate::errors::{InputValue, LocItem, ValResult};
 use crate::{PyMultiHostUrl, PyUrl};
 
@@ -45,11 +44,6 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         None
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn validated_data(&self) -> Option<ValidatedData> {
-        None
-    }
-
     // input_ prefix to differentiate from the function on PyAny
     fn input_is_instance(&self, class: &PyAny, json_mask: u8) -> PyResult<bool>;
 

src/input/input_python.rs

@@ -11,7 +11,6 @@ use pyo3::types::{
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
 use pyo3::{ffi, intern, AsPyPointer, PyTypeInfo};
 
-use crate::argument_markers::{ValidatedData, VALIDATED_DATA_KEY};
 use crate::build_tools::safe_repr;
 use crate::errors::{ErrorType, InputValue, LocItem, ValError, ValResult};
 use crate::{ArgsKwargs, PyMultiHostUrl, PyUrl};
@@ -103,16 +102,6 @@ impl<'a> Input<'a> for PyAny {
         Some(self.getattr(name))
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
-    fn validated_data(&self) -> Option<ValidatedData> {
-        if let Ok(v) = self.get_item(intern!(self.py(), VALIDATED_DATA_KEY)) {
-            if let Ok(validated_data) = v.extract::<ValidatedData>() {
-                return Some(validated_data);
-            }
-        }
-        None
-    }
-
     fn input_is_instance(&self, class: &PyAny, _json_mask: u8) -> PyResult<bool> {
         // See PyO3/pyo3#2694 - we can't use `is_instance` here since it requires PyType,
         // and some check objects are not types, this logic is lifted from `is_instance` in PyO3

src/validators/model.rs

@@ -7,7 +7,6 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet, PyString, PyTuple, PyType};
 use pyo3::{ffi, intern};
 
-use crate::argument_markers::{ValidatedData, VALIDATED_DATA_KEY};
 use crate::build_tools::{py_err, schema_or_config_same, SchemaDict};
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::{py_error_on_minusone, Input};
@@ -56,7 +55,6 @@ pub struct ModelValidator {
     post_init: Option<Py<PyString>>,
     name: String,
     frozen: bool,
-    custom_init: bool,
 }
 
 impl BuildValidator for ModelValidator {
@@ -93,7 +91,6 @@ impl BuildValidator for ModelValidator {
             // which is not what we want here
             name: class.getattr(intern!(py, "__name__"))?.extract()?,
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
-            custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
         }
         .into())
     }
@@ -243,19 +240,6 @@ impl ModelValidator {
             ..*extra
         };
 
-        if self.custom_init {
-            if let Some(validated_data) = input.validated_data() {
-                set_model_attrs(
-                    self_instance,
-                    validated_data.model_dict.as_ref(py),
-                    validated_data.model_extra.as_ref(py),
-                    validated_data.fields_set.as_ref(py),
-                )?;
-                // we don't call post_init here, it'll be called by the original validator
-                return Ok(self_instance.into_py(py));
-            }
-        }
-
         let output = self.validator.validate(py, input, &new_extra, slots, recursion_guard)?;
         let (model_dict, model_extra, fields_set): (&PyAny, &PyAny, &PyAny) = output.extract(py)?;
         set_model_attrs(self_instance, model_dict, model_extra, fields_set)?;
@@ -279,16 +263,9 @@ impl ModelValidator {
 
     fn create_class(&self, model_dict: &PyAny, model_extra: &PyAny, fields_set: &PyAny) -> PyResult<PyObject> {
         let py = model_dict.py();
-        if self.custom_init {
-            let kwargs = PyDict::new(py);
-            let vd = ValidatedData::new(model_dict, model_extra, fields_set);
-            kwargs.set_item(intern!(py, VALIDATED_DATA_KEY), vd.into_py(py))?;
-            self.class.call(py, (), Some(kwargs))
-        } else {
-            let instance = create_class(self.class.as_ref(py))?;
-            set_model_attrs(instance.as_ref(py), model_dict, model_extra, fields_set)?;
-            Ok(instance)
-        }
+        let instance = create_class(self.class.as_ref(py))?;
+        set_model_attrs(instance.as_ref(py), model_dict, model_extra, fields_set)?;
+        Ok(instance)
     }
 }
 

tests/validators/test_model.py

@@ -1164,157 +1164,3 @@ def f(values_or_values_and_fields_set: Any, *args: Any) -> Any:
     assert m.b == 2
     assert m.__pydantic_fields_set__ == {'a', 'b'}
     assert calls == [call1, call2]
-
-
-def test_custom_init():
-    calls = []
-
-    class Model:
-        __slots__ = '__dict__', '__pydantic_extra__', '__pydantic_fields_set__'
-
-        def __init__(self, **kwargs):
-            validated_data = kwargs['validated_data']
-            self.a = validated_data.model_dict['a']
-            self.b = validated_data.model_dict['b']
-            self.__pydantic_fields_set__ = validated_data.fields_set
-            calls.append(repr(kwargs))
-
-    v = SchemaValidator(
-        core_schema.model_schema(
-            Model,
-            core_schema.model_fields_schema(
-                {
-                    'a': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=1)),
-                    'b': core_schema.model_field(core_schema.int_schema()),
-                }
-            ),
-            custom_init=True,
-        )
-    )
-
-    m = v.validate_python({'b': 2})
-    assert m.a == 1
-    assert m.b == 2
-    assert m.__pydantic_fields_set__ == {'b'}
-    assert calls == [
-        "{'validated_data': ValidatedData(model_dict={'a': 1, 'b': 2}, model_extra=None, fields_set={'b'})}"
-    ]
-
-
-def test_custom_init_nested():
-    calls = []
-
-    class ModelInner:
-        __slots__ = '__dict__', '__pydantic_extra__', '__pydantic_fields_set__'
-        a: int
-        b: int
-
-        def __init__(self, **data):
-            calls.append(f'inner: {data!r}')
-            self.__pydantic_validator__.validate_python(data, self_instance=self)
-
-    inner_schema = core_schema.model_schema(
-        ModelInner,
-        core_schema.model_fields_schema(
-            {
-                'a': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=1)),
-                'b': core_schema.model_field(core_schema.int_schema()),
-            }
-        ),
-        custom_init=True,
-    )
-    ModelInner.__pydantic_validator__ = SchemaValidator(inner_schema)
-
-    class ModelOuter:
-        __slots__ = '__dict__', '__pydantic_extra__', '__pydantic_fields_set__'
-        a: int
-        b: ModelInner
-
-        def __init__(self, **data):
-            calls.append(f'outer: {data!r}')
-            self.__pydantic_validator__.validate_python(data, self_instance=self)
-
-    ModelOuter.__pydantic_validator__ = SchemaValidator(
-        core_schema.model_schema(
-            ModelOuter,
-            core_schema.model_fields_schema(
-                {
-                    'a': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=1)),
-                    'b': core_schema.model_field(inner_schema),
-                }
-            ),
-            custom_init=True,
-        )
-    )
-
-    m = ModelOuter(a=2, b={'b': 3})
-    assert m.__pydantic_fields_set__ == {'a', 'b'}
-    assert m.a == 2
-    assert isinstance(m.b, ModelInner)
-    assert m.b.a == 1
-    assert m.b.b == 3
-    # insert_assert(calls)
-    assert calls == [
-        "outer: {'a': 2, 'b': {'b': 3}}",
-        "inner: {'validated_data': ValidatedData(model_dict={'a': 1, 'b': 3}, model_extra=None, fields_set={'b'})}",
-    ]
-
-
-class BadValidatedData:
-    """
-    Attempt to confuse validation with a mock of ValidatedData should fail
-    """
-
-    def __init__(self, model_dict: Dict[str, Any], fields_set: Set[str]):
-        self.model_dict = model_dict
-        self.fields_set = fields_set
-
-
-def test_custom_init_mock():
-    calls = []
-
-    class Model:
-        def __init__(self, **kwargs):
-            validated_data = kwargs['validated_data']
-            self.a = validated_data.model_dict['a']
-            calls.append(repr(validated_data))
-
-    v = SchemaValidator(
-        core_schema.model_schema(
-            Model,
-            core_schema.model_fields_schema({'a': core_schema.model_field(core_schema.int_schema())}),
-            custom_init=True,
-        )
-    )
-
-    m = v.validate_python({'a': 2})
-    assert m.a == 2
-    assert calls == ["ValidatedData(model_dict={'a': 2}, model_extra=None, fields_set={'a'})"]
-
-    with pytest.raises(ValidationError, match=r'Field required \[type=missing,'):
-        v.validate_python({'validated_data': BadValidatedData({'a': 2}, {'a'})})
-
-
-def test_custom_init_validated_data_field():
-    calls = []
-
-    class Model:
-        def __init__(self, **kwargs):
-            validated_data = kwargs['validated_data']
-            self.validated_data = validated_data.model_dict['validated_data']
-            calls.append(repr(validated_data))
-
-    v = SchemaValidator(
-        core_schema.model_schema(
-            Model,
-            core_schema.model_fields_schema({'validated_data': core_schema.model_field(core_schema.int_schema())}),
-            custom_init=True,
-        )
-    )
-
-    m = v.validate_python({'validated_data': 2})
-    assert m.validated_data == 2
-    assert calls == ["ValidatedData(model_dict={'validated_data': 2}, model_extra=None, fields_set={'validated_data'})"]
-
-    with pytest.raises(ValidationError, match='Input should be a valid integer'):
-        v.validate_python({'validated_data': BadValidatedData({'a': 2}, {'a'})})