validating default value (#479)

* validating default value

* internal ValueError on invalid default value

* raise ValidationError on invalid default

Author: samuelcolvin

.rustfmt.toml

@@ -1,2 +1 @@
 max_width = 120
-imports_granularity = "Module"

pydantic_core/core_schema.py

@@ -32,6 +32,8 @@ class CoreConfig(TypedDict, total=False):
     # used on typed-dicts and tagged union keys
     from_attributes: bool
     revalidate_models: bool
+    # whether to validate default values during validation, default False
+    validate_default: bool
     # used on typed-dicts and arguments
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     # fields related to string fields only
@@ -2068,6 +2070,7 @@ class WithDefaultSchema(TypedDict, total=False):
     default: Any
     default_factory: Callable[[], Any]
     on_error: Literal['raise', 'omit', 'default']  # default: 'raise'
+    validate_default: bool  # default: False
     strict: bool
     ref: str
     metadata: Any
@@ -2083,6 +2086,7 @@ def with_default_schema(
     default: Any = Omitted,
     default_factory: Callable[[], Any] | None = None,
     on_error: Literal['raise', 'omit', 'default'] | None = None,
+    validate_default: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
@@ -2107,6 +2111,7 @@ def with_default_schema(
         default: The default value to use
         default_factory: A function that returns the default value to use
         on_error: What to do if the schema validation fails. One of 'raise', 'omit', 'default'
+        validate_default: Whether the default value should be validated
         strict: Whether the underlying schema should be validated with strict mode
         ref: See [TODO] for details
         metadata: See [TODO] for details
@@ -2117,6 +2122,7 @@ def with_default_schema(
         schema=schema,
         default_factory=default_factory,
         on_error=on_error,
+        validate_default=validate_default,
         strict=strict,
         ref=ref,
         metadata=metadata,

src/serializers/shared.rs

@@ -275,6 +275,10 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
     fn retry_with_lax_check(&self) -> bool {
         false
     }
+
+    fn get_default(&self, _py: Python) -> PyResult<Option<PyObject>> {
+        Ok(None)
+    }
 }
 
 pub(crate) struct PydanticSerializer<'py> {

src/serializers/type_serializers/typed_dict.rs

@@ -11,7 +11,6 @@ use crate::build_context::BuildContext;
 use crate::build_tools::{py_error_type, schema_or_config, SchemaDict};
 use crate::PydanticSerializationUnexpectedValue;
 
-use super::with_default::get_default;
 use super::{
     infer_json_key, infer_serialize, infer_to_python, py_err_se_err, BuildSerializer, CombinedSerializer, Extra,
     PydanticSerializer, SchemaFilter, SerializeInfer, TypeSerializer,
@@ -145,8 +144,8 @@ impl TypedDictSerializer {
 
     fn exclude_default(&self, value: &PyAny, extra: &Extra, field: &TypedDictField) -> PyResult<bool> {
         if extra.exclude_defaults {
-            if let Some(default) = get_default(value.py(), &field.serializer)? {
-                if value.eq(default.as_ref())? {
+            if let Some(default) = field.serializer.get_default(value.py())? {
+                if value.eq(default)? {
                     return Ok(true);
                 }
             }

src/serializers/type_serializers/with_default.rs

@@ -34,17 +34,6 @@ impl BuildSerializer for WithDefaultSerializer {
     }
 }
 
-pub(super) fn get_default<'a>(
-    py: Python<'a>,
-    serializer: &'a CombinedSerializer,
-) -> PyResult<Option<Cow<'a, PyObject>>> {
-    if let CombinedSerializer::WithDefault(serializer) = serializer {
-        serializer.default.default_value(py)
-    } else {
-        Ok(None)
-    }
-}
-
 impl TypeSerializer for WithDefaultSerializer {
     fn to_python(
         &self,
@@ -79,4 +68,8 @@ impl TypeSerializer for WithDefaultSerializer {
     fn retry_with_lax_check(&self) -> bool {
         self.serializer.retry_with_lax_check()
     }
+
+    fn get_default(&self, py: Python) -> PyResult<Option<PyObject>> {
+        self.default.default_value(py)
+    }
 }

src/validators/arguments.rs

@@ -10,7 +10,6 @@ use crate::input::{GenericArguments, Input};
 use crate::lookup_key::LookupKey;
 use crate::recursion_guard::RecursionGuard;
 
-use super::with_default::get_default;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
@@ -221,11 +220,11 @@ impl Validator for ArgumentsValidator {
                             }
                         }
                         (None, None) => {
-                            if let Some(value) = get_default(py, &parameter.validator)? {
+                            if let Some(value) = parameter.validator.default_value(py, Some(parameter.name.as_str()), extra, slots, recursion_guard)? {
                                 if let Some(ref kwarg_key) = parameter.kwarg_key {
-                                    output_kwargs.set_item(kwarg_key, value.as_ref())?;
+                                    output_kwargs.set_item(kwarg_key, value)?;
                                 } else {
-                                    output_args.push(value.as_ref().clone_ref(py));
+                                    output_args.push(value);
                                 }
                             } else if parameter.kwarg_key.is_some() {
                                 errors.push(ValLineError::new_with_loc(

src/validators/dataclass.rs

@@ -14,7 +14,6 @@ use crate::validators::function::convert_err;
 
 use super::arguments::{json_get, json_slice, py_get, py_slice};
 use super::model::{create_class, force_setattr};
-use super::with_default::get_default;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
@@ -221,8 +220,14 @@ impl Validator for DataclassArgsValidator {
                         }
                         // found neither, check if there is a default value, otherwise error
                         (None, None) => {
-                            if let Some(value) = get_default(py, &field.validator)? {
-                                set_item!(field, value.as_ref().clone_ref(py));
+                            if let Some(value) = field.validator.default_value(
+                                py,
+                                Some(field.name.as_str()),
+                                &extra,
+                                slots,
+                                recursion_guard,
+                            )? {
+                                set_item!(field, value);
                             } else {
                                 errors.push(ValLineError::new_with_loc(
                                     ErrorType::MissingKeywordArgument,

src/validators/mod.rs

@@ -9,7 +9,7 @@ use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::build_context::BuildContext;
 use crate::build_tools::{py_err, py_error_type, SchemaDict, SchemaError};
-use crate::errors::{ValError, ValResult, ValidationError};
+use crate::errors::{LocItem, ValError, ValResult, ValidationError};
 use crate::input::Input;
 use crate::questions::{Answers, Question};
 use crate::recursion_guard::RecursionGuard;
@@ -602,6 +602,18 @@ pub trait Validator: Send + Sync + Clone + Debug {
         recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject>;
 
+    /// Get a default value, currently only used by `WithDefaultValidator`
+    fn default_value<'s, 'data>(
+        &'s self,
+        _py: Python<'data>,
+        _outer_loc: Option<impl Into<LocItem>>,
+        _extra: &Extra,
+        _slots: &'data [CombinedValidator],
+        _recursion_guard: &'s mut RecursionGuard,
+    ) -> ValResult<'data, Option<PyObject>> {
+        Ok(None)
+    }
+
     /// `get_name` generally returns `Self::EXPECTED_TYPE` or some other clear identifier of the validator
     /// this is used in the error location in unions, and in the top level message in `ValidationError`
     fn get_name(&self) -> &str;

src/validators/tuple.rs

@@ -8,7 +8,6 @@ use crate::input::{GenericCollection, Input};
 use crate::recursion_guard::RecursionGuard;
 
 use super::list::{get_items_schema, length_check};
-use super::with_default::get_default;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
@@ -155,8 +154,10 @@ impl Validator for TuplePositionalValidator {
                             Err(err) => return Err(err),
                         },
                         None => {
-                            if let Some(value) = get_default(py, &validator)? {
-                                output.push(value.as_ref().clone_ref(py));
+                            if let Some(value) =
+                                validator.default_value(py, Some(index), extra, slots, recursion_guard)?
+                            {
+                                output.push(value);
                             } else {
                                 errors.push(ValLineError::new_with_loc(ErrorType::Missing, input, index));
                             }

src/validators/typed_dict.rs

@@ -15,7 +15,6 @@ use crate::lookup_key::LookupKey;
 use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 
-use super::with_default::get_default;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
@@ -230,8 +229,8 @@ impl Validator for TypedDictValidator {
                             Err(err) => return Err(err),
                         }
                         continue;
-                    } else if let Some(value) = get_default(py, &field.validator)? {
-                        output_dict.set_item(&field.name_py, value.as_ref())?;
+                    } else if let Some(value) = field.validator.default_value(py, Some(field.name.as_str()), &extra, slots, recursion_guard)? {
+                        output_dict.set_item(&field.name_py, value)?;
                     } else if field.required {
                         errors.push(ValLineError::new_with_loc(
                             ErrorType::Missing,