validating default value (#479)

samuelcolvin · web-flow · commit f4759a38be7b · 2023-03-27T15:57:09.000-06:00
* validating default value

* internal ValueError on invalid default value

* raise ValidationError on invalid default
diff --git a/.rustfmt.toml b/.rustfmt.toml
@@ -1,2 +1 @@
 max_width = 120
-imports_granularity = "Module"
diff --git a/pydantic_core/core_schema.py b/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,
diff --git a/src/serializers/shared.rs b/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> {
diff --git a/src/serializers/type_serializers/typed_dict.rs b/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);
                 }
             }
diff --git a/src/serializers/type_serializers/with_default.rs b/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)
+    }
 }
diff --git a/src/validators/arguments.rs b/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(
diff --git a/src/validators/dataclass.rs b/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,
diff --git a/src/validators/mod.rs b/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;
diff --git a/src/validators/tuple.rs b/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));
                             }
diff --git a/src/validators/typed_dict.rs b/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,
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
@@ -1,11 +1,9 @@
-use std::borrow::Cow;
-
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::build_tools::{py_err, SchemaDict};
-use crate::errors::{ValError, ValResult};
+use crate::build_tools::{py_err, schema_or_config_same, SchemaDict};
+use crate::errors::{LocItem, ValError, ValResult};
 use crate::input::Input;
 use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
@@ -33,10 +31,10 @@ impl DefaultType {
         }
     }
 
-    pub fn default_value(&self, py: Python) -> PyResult<Option<Cow<PyObject>>> {
+    pub fn default_value(&self, py: Python) -> PyResult<Option<PyObject>> {
         match self {
-            Self::Default(ref default) => Ok(Some(Cow::Borrowed(default))),
-            Self::DefaultFactory(ref default_factory) => Ok(Some(Cow::Owned(default_factory.call0(py)?))),
+            Self::Default(ref default) => Ok(Some(default.clone_ref(py))),
+            Self::DefaultFactory(ref default_factory) => Ok(Some(default_factory.call0(py)?)),
             Self::None => Ok(None),
         }
     }
@@ -54,6 +52,7 @@ pub struct WithDefaultValidator {
     default: DefaultType,
     on_error: OnError,
     validator: Box<CombinedValidator>,
+    validate_default: bool,
     name: String,
 }
 
@@ -89,6 +88,7 @@ impl BuildValidator for WithDefaultValidator {
             default,
             on_error,
             validator,
+            validate_default: schema_or_config_same(schema, config, intern!(py, "validate_default"))?.unwrap_or(false),
             name,
         }
         .into())
@@ -108,12 +108,43 @@ impl Validator for WithDefaultValidator {
             Ok(v) => Ok(v),
             Err(e) => match self.on_error {
                 OnError::Raise => Err(e),
-                OnError::Default => Ok(self.default.default_value(py)?.unwrap().as_ref().clone()),
+                OnError::Default => Ok(self
+                    .default_value(py, None::<usize>, extra, slots, recursion_guard)?
+                    .unwrap()),
                 OnError::Omit => Err(ValError::Omit),
             },
         }
     }
 
+    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>> {
+        match self.default.default_value(py)? {
+            Some(dft) => {
+                if self.validate_default {
+                    match self.validate(py, dft.into_ref(py), extra, slots, recursion_guard) {
+                        Ok(v) => Ok(Some(v)),
+                        Err(e) => {
+                            if let Some(outer_loc) = outer_loc {
+                                Err(e.with_outer_location(outer_loc.into()))
+                            } else {
+                                Err(e)
+                            }
+                        }
+                    }
+                } else {
+                    Ok(Some(dft))
+                }
+            }
+            None => Ok(None),
+        }
+    }
+
     fn get_name(&self) -> &str {
         &self.name
     }
@@ -136,11 +167,3 @@ impl WithDefaultValidator {
         matches!(self.on_error, OnError::Omit)
     }
 }
-
-pub fn get_default<'a>(py: Python<'a>, validator: &'a CombinedValidator) -> PyResult<Option<Cow<'a, PyObject>>> {
-    if let CombinedValidator::WithDefault(validator) = validator {
-        validator.default.default_value(py)
-    } else {
-        Ok(None)
-    }
-}
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1 @@`
`1`	`1`	`max_width = 120`
`2`		`-imports_granularity = "Module"`
Original file line number	Diff line number	Diff line change
`@@ -275,6 +275,10 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {`
`275`	`275`	`fn retry_with_lax_check(&self) -> bool {`
`276`	`276`	`false`
`277`	`277`	`}`
	`278`	`+`
	`279`	`+ fn get_default(&self, _py: Python) -> PyResult<Option<PyObject>> {`
	`280`	`+ Ok(None)`
	`281`	`+ }`
`278`	`282`	`}`
`279`	`283`
`280`	`284`	`pub(crate) struct PydanticSerializer<'py> {`