custom_init and remove expect_fields_set

Author: samuelcolvin

pydantic_core/core_schema.py

@@ -2737,6 +2737,7 @@ 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
@@ -2751,6 +2752,7 @@ 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,
@@ -2775,6 +2777,7 @@ class MyModel:
         config=CoreConfig(str_max_length=5),
         schema=core_schema.typed_dict_schema(
             fields={'a': core_schema.typed_dict_field(core_schema.str_schema())},
+            return_fields_set=True,
         ),
     )
     v = SchemaValidator(schema)
@@ -2790,6 +2793,7 @@ 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
@@ -2803,6 +2807,7 @@ class MyModel:
         revalidate_instances=revalidate_instances,
         strict=strict,
         frozen=frozen,
+        custom_init=custom_init,
         config=config,
         ref=ref,
         metadata=metadata,
@@ -3239,7 +3244,8 @@ def json_schema(
         {
             'field_a': core_schema.typed_dict_field(core_schema.str_schema()),
             'field_b': core_schema.typed_dict_field(core_schema.bool_schema()),
-        }
+        },
+        return_fields_set=True,
     )
 
     class MyModel:

src/args_kwargs.rs

@@ -60,3 +60,30 @@ 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 fields_set: PyObject,
+}
+
+impl ValidatedData {
+    pub(crate) fn new(model_dict: &PyAny, fields_set: &PyAny) -> Self {
+        Self {
+            model_dict: model_dict.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 fields_set = safe_repr(self.fields_set.as_ref(py));
+        format!("ValidatedData(model_dict={model_dict}, fields_set={fields_set})")
+    }
+}

src/build_context.rs

@@ -5,15 +5,13 @@ use pyo3::types::{PyDict, PyList};
 use ahash::{AHashMap, AHashSet};
 
 use crate::build_tools::{py_err, py_error_type, SchemaDict};
-use crate::questions::Answers;
 use crate::serializers::CombinedSerializer;
 use crate::validators::{CombinedValidator, Validator};
 
 #[derive(Clone, Debug)]
 struct Slot<T> {
     slot_ref: String,
     op_val_ser: Option<T>,
-    answers: Option<Answers>,
 }
 
 pub enum ThingOrId<T> {
@@ -83,12 +81,11 @@ impl<T: Clone + std::fmt::Debug> BuildContext<T> {
     /// First of two part process to add a new validator/serializer slot, we add the `slot_ref` to the array,
     /// but not the actual `validator`/`serializer`, we can't add that until it's build.
     /// But we need the `id` to build it, hence this two-step process.
-    pub fn prepare_slot(&mut self, slot_ref: String, answers: Option<Answers>) -> PyResult<usize> {
+    pub fn prepare_slot(&mut self, slot_ref: String) -> PyResult<usize> {
         let id = self.slots.len();
         let slot = Slot {
             slot_ref,
             op_val_ser: None,
-            answers,
         };
         self.slots.push(slot);
         Ok(id)
@@ -101,7 +98,6 @@ impl<T: Clone + std::fmt::Debug> BuildContext<T> {
                 self.slots[slot_id] = Slot {
                     slot_ref: slot.slot_ref.clone(),
                     op_val_ser: Some(val_ser),
-                    answers: slot.answers.clone(),
                 };
                 Ok(())
             }
@@ -123,14 +119,6 @@ impl<T: Clone + std::fmt::Debug> BuildContext<T> {
         }
     }
 
-    /// get a slot answer by `id`
-    pub fn get_slot_answer(&self, slot_id: usize) -> PyResult<Option<Answers>> {
-        match self.slots.get(slot_id) {
-            Some(slot) => Ok(slot.answers.clone()),
-            None => py_err!("Slots Error: slot {} not found", slot_id),
-        }
-    }
-
     /// find a validator/serializer by `slot_id` - this used in `Validator.complete`,
     /// specifically `DefinitionRefValidator` to set its name
     pub fn find_validator(&self, slot_id: usize) -> PyResult<&T> {

src/input/input_abstract.rs

@@ -3,6 +3,7 @@ use std::fmt;
 use pyo3::prelude::*;
 use pyo3::types::{PyString, PyType};
 
+use crate::args_kwargs::ValidatedData;
 use crate::errors::{InputValue, LocItem, ValResult};
 use crate::{PyMultiHostUrl, PyUrl};
 
@@ -44,6 +45,11 @@ 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,6 +11,7 @@ use pyo3::types::{
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
 use pyo3::{ffi, intern, AsPyPointer, PyTypeInfo};
 
+use crate::args_kwargs::{ValidatedData, VALIDATED_DATA_KEY};
 use crate::build_tools::safe_repr;
 use crate::errors::{ErrorType, InputValue, LocItem, ValError, ValResult};
 use crate::{ArgsKwargs, PyMultiHostUrl, PyUrl};
@@ -102,6 +103,16 @@ 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/lib.rs

@@ -16,7 +16,6 @@ mod errors;
 mod input;
 mod lazy_index_map;
 mod lookup_key;
-mod questions;
 mod recursion_guard;
 mod serializers;
 mod url;

src/questions.rs

@@ -214,7 +214,7 @@ impl BuildSerializer for CombinedSerializer {
                 return if build_context.ref_used_within(schema, &schema_ref)? {
                     // the ref is used within itself, so we have to store the serializer in slots
                     // and return a DefinitionRefSerializer
-                    let slot_id = build_context.prepare_slot(schema_ref, None)?;
+                    let slot_id = build_context.prepare_slot(schema_ref)?;
                     let inner_ser = Self::_build(schema, config, build_context)?;
                     build_context.complete_slot(slot_id, inner_ser)?;
                     Ok(super::type_serializers::definitions::DefinitionRefSerializer::from_id(

src/serializers/shared.rs

@@ -5,7 +5,6 @@ use pyo3::types::{PyDict, PyList};
 use crate::build_tools::{py_err, SchemaDict};
 use crate::errors::ValResult;
 use crate::input::Input;
-use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
@@ -99,12 +98,6 @@ impl Validator for ChainValidator {
         &self.name
     }
 
-    fn ask(&self, question: &Question) -> bool {
-        // any makes more sense since at the moment we only use ask for "return_fields_set", might need
-        // more complex logic in future
-        self.steps.iter().any(|v| v.ask(question))
-    }
-
     fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
         self.steps.iter_mut().try_for_each(|v| v.complete(build_context))
     }

src/validators/chain.rs

@@ -5,7 +5,6 @@ use pyo3::types::PyDict;
 use crate::build_tools::{py_err, SchemaDict};
 use crate::errors::{ErrorType, PydanticCustomError, PydanticKnownError, ValError, ValResult};
 use crate::input::Input;
-use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
@@ -109,10 +108,6 @@ impl Validator for CustomErrorValidator {
         &self.name
     }
 
-    fn ask(&self, question: &Question) -> bool {
-        self.validator.ask(question)
-    }
-
     fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
         self.validator.complete(build_context)
     }

src/validators/custom_error.rs

@@ -6,7 +6,6 @@ use crate::build_context::{BuildContext, ThingOrId};
 use crate::build_tools::SchemaDict;
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::Input;
-use crate::questions::{Answers, Question};
 use crate::recursion_guard::RecursionGuard;
 
 use super::{build_validator, BuildValidator, CombinedValidator, Extra, Validator};
@@ -41,15 +40,13 @@ pub struct DefinitionRefValidator {
     validator_id: usize,
     inner_name: String,
     // we have to record the answers to `Question`s as we can't access the validator when `ask()` is called
-    answers: Answers,
 }
 
 impl DefinitionRefValidator {
-    pub fn from_id(validator_id: usize, inner_name: String, answers: Answers) -> CombinedValidator {
+    pub fn from_id(validator_id: usize, inner_name: String) -> CombinedValidator {
         Self {
             validator_id,
             inner_name,
-            answers,
         }
         .into()
     }
@@ -67,15 +64,11 @@ impl BuildValidator for DefinitionRefValidator {
 
         match build_context.find(&schema_ref)? {
             ThingOrId::Thing(validator) => Ok(validator),
-            ThingOrId::Id(validator_id) => {
-                let answers = build_context.get_slot_answer(validator_id)?;
-                Ok(Self {
-                    validator_id,
-                    inner_name: "...".to_string(),
-                    answers: answers.unwrap(),
-                }
-                .into())
+            ThingOrId::Id(validator_id) => Ok(Self {
+                validator_id,
+                inner_name: "...".to_string(),
             }
+            .into()),
         }
     }
 }
@@ -125,10 +118,6 @@ impl Validator for DefinitionRefValidator {
         &self.inner_name
     }
 
-    fn ask(&self, question: &Question) -> bool {
-        self.answers.ask(question)
-    }
-
     /// don't need to call complete on the inner validator here, complete_validators takes care of that.
     fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
         let validator = build_context.find_validator(self.validator_id)?;

src/validators/definitions.rs

@@ -8,7 +8,6 @@ use crate::errors::{
     ErrorType, LocItem, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
 };
 use crate::input::Input;
-use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 
 use super::generator::InternalValidator;
@@ -111,10 +110,6 @@ macro_rules! impl_validator {
                 &self.name
             }
 
-            fn ask(&self, question: &Question) -> bool {
-                self.validator.ask(question)
-            }
-
             fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
                 self.validator.complete(build_context)
             }
@@ -341,10 +336,6 @@ impl Validator for FunctionWrapValidator {
         &self.name
     }
 
-    fn ask(&self, question: &Question) -> bool {
-        self.validator.ask(question)
-    }
-
     fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
         self.validator.complete(build_context)
     }

src/validators/function.rs

@@ -6,7 +6,6 @@ use pyo3::types::PyDict;
 use crate::build_tools::SchemaDict;
 use crate::errors::{ErrorMode, ErrorType, LocItem, ValError, ValResult};
 use crate::input::{GenericIterator, Input};
-use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 use crate::ValidationError;
 
@@ -84,13 +83,6 @@ impl Validator for GeneratorValidator {
         &self.name
     }
 
-    fn ask(&self, question: &Question) -> bool {
-        match self.item_validator {
-            Some(ref v) => v.ask(question),
-            None => false,
-        }
-    }
-
     fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
         match self.item_validator {
             Some(ref mut v) => v.complete(build_context),

src/validators/generator.rs

@@ -5,7 +5,6 @@ use pyo3::types::PyDict;
 use crate::build_tools::SchemaDict;
 use crate::errors::ValResult;
 use crate::input::Input;
-use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
@@ -78,10 +77,6 @@ impl Validator for JsonValidator {
         &self.name
     }
 
-    fn ask(&self, question: &Question) -> bool {
-        self.validator.as_ref().map(|v| v.ask(question)).unwrap_or(false)
-    }
-
     fn complete(&mut self, build_context: &BuildContext<CombinedValidator>) -> PyResult<()> {
         match self.validator {
             Some(ref mut v) => v.complete(build_context),