Add hide_input to ValidationError

Author: hramezani

pydantic_core/_pydantic_core.pyi

@@ -173,7 +173,10 @@ class SchemaError(Exception):
 class ValidationError(ValueError):
     @staticmethod
     def from_exception_data(
-        title: str, errors: 'list[InitErrorDetails]', error_mode: Literal['python', 'json'] = 'python'
+        title: str,
+        errors: 'list[InitErrorDetails]',
+        error_mode: Literal['python', 'json'] = 'python',
+        hide_input: bool = False,
     ) -> ValidationError:
         """
         Provisory constructor for a Validation Error.

pydantic_core/core_schema.py

@@ -51,6 +51,7 @@ class CoreConfig(TypedDict, total=False):
     # the config options are used to customise serialization to JSON
     ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64']  # default: 'utf8'
+    hide_input_in_errors: bool
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'

src/build_tools.rs

@@ -140,7 +140,7 @@ impl SchemaError {
         match error {
             ValError::LineErrors(raw_errors) => {
                 let line_errors = raw_errors.into_iter().map(|e| e.into_py(py)).collect();
-                let validation_error = ValidationError::new(line_errors, "Schema".to_object(py), ErrorMode::Python);
+                let validation_error = ValidationError::new(line_errors, "Schema".to_object(py), ErrorMode::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
                     Ok(err) => PyErr::from_value(err.into_ref(py)),
@@ -177,21 +177,21 @@ impl SchemaError {
     fn errors(&self, py: Python) -> PyResult<Py<PyList>> {
         match &self.0 {
             SchemaErrorEnum::Message(_) => Ok(PyList::empty(py).into_py(py)),
-            SchemaErrorEnum::ValidationError(error) => error.errors(py, false, true),
+            SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false),
         }
     }
 
     fn __str__(&self, py: Python) -> String {
         match &self.0 {
             SchemaErrorEnum::Message(message) => message.to_owned(),
-            SchemaErrorEnum::ValidationError(error) => error.display(py, Some("Invalid Schema:")),
+            SchemaErrorEnum::ValidationError(error) => error.display(py, Some("Invalid Schema:"), false),
         }
     }
 
     fn __repr__(&self, py: Python) -> String {
         match &self.0 {
             SchemaErrorEnum::Message(message) => format!("SchemaError({message:?})"),
-            SchemaErrorEnum::ValidationError(error) => error.display(py, Some("Invalid Schema:")),
+            SchemaErrorEnum::ValidationError(error) => error.display(py, Some("Invalid Schema:"), false),
         }
     }
 }

src/errors/validation_exception.rs

@@ -31,14 +31,16 @@ pub struct ValidationError {
     line_errors: Vec<PyLineError>,
     error_mode: ErrorMode,
     title: PyObject,
+    hide_input: bool,
 }
 
 impl ValidationError {
-    pub fn new(line_errors: Vec<PyLineError>, title: PyObject, error_mode: ErrorMode) -> Self {
+    pub fn new(line_errors: Vec<PyLineError>, title: PyObject, error_mode: ErrorMode, hide_input: bool) -> Self {
         Self {
             line_errors,
             title,
             error_mode,
+            hide_input,
         }
     }
 
@@ -48,6 +50,7 @@ impl ValidationError {
         error_mode: ErrorMode,
         error: ValError,
         outer_location: Option<LocItem>,
+        hide_input: bool,
     ) -> PyErr {
         match error {
             ValError::LineErrors(raw_errors) => {
@@ -58,7 +61,7 @@ impl ValidationError {
                         .collect(),
                     None => raw_errors.into_iter().map(|e| e.into_py(py)).collect(),
                 };
-                let validation_error = Self::new(line_errors, title, error_mode);
+                let validation_error = Self::new(line_errors, title, error_mode, hide_input);
                 match Py::new(py, validation_error) {
                     Ok(err) => PyErr::from_value(err.into_ref(py)),
                     Err(err) => err,
@@ -69,9 +72,9 @@ impl ValidationError {
         }
     }
 
-    pub fn display(&self, py: Python, prefix_override: Option<&'static str>) -> String {
+    pub fn display(&self, py: Python, prefix_override: Option<&'static str>, hide_input: bool) -> String {
         let url_prefix = get_url_prefix(py, include_url_env(py));
-        let line_errors = pretty_py_line_errors(py, &self.error_mode, self.line_errors.iter(), url_prefix);
+        let line_errors = pretty_py_line_errors(py, &self.error_mode, self.line_errors.iter(), url_prefix, hide_input);
         if let Some(prefix) = prefix_override {
             format!("{prefix}\n{line_errors}")
         } else {
@@ -129,13 +132,18 @@ impl ValidationError {
         title: PyObject,
         line_errors: &PyList,
         error_mode: Option<&str>,
+        hide_input: Option<bool>,
     ) -> PyResult<Py<Self>> {
         Py::new(
             py,
             Self {
                 line_errors: line_errors.iter().map(PyLineError::try_from).collect::<PyResult<_>>()?,
                 title,
                 error_mode: ErrorMode::try_from(error_mode)?,
+                hide_input: match hide_input {
+                    Some(t) => t,
+                    None => false,
+                },
             },
         )
     }
@@ -210,7 +218,7 @@ impl ValidationError {
     }
 
     fn __repr__(&self, py: Python) -> String {
-        self.display(py, None)
+        self.display(py, None, self.hide_input)
     }
 
     fn __str__(&self, py: Python) -> String {
@@ -238,9 +246,10 @@ pub fn pretty_py_line_errors<'a>(
     error_mode: &ErrorMode,
     line_errors_iter: impl Iterator<Item = &'a PyLineError>,
     url_prefix: Option<&str>,
+    hide_input: bool,
 ) -> String {
     line_errors_iter
-        .map(|i| i.pretty(py, error_mode, url_prefix))
+        .map(|i| i.pretty(py, error_mode, url_prefix, hide_input))
         .collect::<Result<Vec<_>, _>>()
         .unwrap_or_else(|err| vec![format!("[error formatting line errors: {err}]")])
         .join("\n")
@@ -349,7 +358,7 @@ impl PyLineError {
         Ok(dict.into_py(py))
     }
 
-    fn pretty(&self, py: Python, error_mode: &ErrorMode, url_prefix: Option<&str>) -> Result<String, fmt::Error> {
+    fn pretty(&self, py: Python, error_mode: &ErrorMode, url_prefix: Option<&str>, hide_input:bool) -> Result<String, fmt::Error> {
         let mut output = String::with_capacity(200);
         write!(output, "{}", self.location)?;
 
@@ -359,12 +368,15 @@ impl PyLineError {
         };
         write!(output, "  {message} [type={}", self.error_type.type_string())?;
 
-        let input_value = self.input_value.as_ref(py);
-        let input_str = safe_repr(input_value);
-        truncate_input_value!(output, input_str);
+        println!("{}", hide_input);
+        if !hide_input {
+            let input_value = self.input_value.as_ref(py);
+            let input_str = safe_repr(input_value);
+            truncate_input_value!(output, input_str);
 
-        if let Ok(type_) = input_value.get_type().name() {
-            write!(output, ", input_type={type_}")?;
+            if let Ok(type_) = input_value.get_type().name() {
+                write!(output, ", input_type={type_}")?;
+            }
         }
         if let Some(url_prefix) = url_prefix {
             match self.error_type {

src/validators/function.rs

@@ -46,6 +46,14 @@ macro_rules! impl_build {
                     function_name(function)?,
                     validator.get_name()
                 );
+                let config_hide_input = match config {
+                    Some(c) => c.get_item("hide_input_in_errors"),
+                    None => None,
+                };
+                let hide_input = match config_hide_input {
+                    Some(t) => t.is_true().unwrap_or(false),
+                    None => false,
+                };
                 Ok(Self {
                     validator: Box::new(validator),
                     func: function.into_py(py),
@@ -56,6 +64,7 @@ macro_rules! impl_build {
                     name,
                     is_field_validator,
                     info_arg,
+                    hide_input,
                 }
                 .into())
             }
@@ -127,6 +136,7 @@ pub struct FunctionBeforeValidator {
     name: String,
     is_field_validator: bool,
     info_arg: bool,
+    hide_input: bool,
 }
 
 impl_build!(FunctionBeforeValidator, "function-before");
@@ -160,6 +170,7 @@ pub struct FunctionAfterValidator {
     name: String,
     is_field_validator: bool,
     info_arg: bool,
+    hide_input: bool,
 }
 
 impl_build!(FunctionAfterValidator, "function-after");
@@ -262,6 +273,7 @@ pub struct FunctionWrapValidator {
     name: String,
     is_field_validator: bool,
     info_arg: bool,
+    hide_input: bool
 }
 
 impl_build!(FunctionWrapValidator, "function-wrap");
@@ -301,6 +313,7 @@ impl Validator for FunctionWrapValidator {
                 definitions,
                 extra,
                 recursion_guard,
+                self.hide_input,
             ),
         };
         self._validate(
@@ -329,6 +342,7 @@ impl Validator for FunctionWrapValidator {
                 definitions,
                 extra,
                 recursion_guard,
+                self.hide_input,
             ),
             updated_field_name: field_name.to_string(),
             updated_field_value: field_value.to_object(py),

src/validators/generator.rs

@@ -18,6 +18,7 @@ pub struct GeneratorValidator {
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: String,
+    hide_input: bool,
 }
 
 impl BuildValidator for GeneratorValidator {
@@ -33,11 +34,20 @@ impl BuildValidator for GeneratorValidator {
             Some(ref v) => format!("{}[{}]", Self::EXPECTED_TYPE, v.get_name()),
             None => format!("{}[any]", Self::EXPECTED_TYPE),
         };
+        let config_hide_input = match config {
+            Some(c) => c.get_item("hide_input_in_errors"),
+            None => None,
+        };
+        let hide_input = match config_hide_input {
+            Some(t) => t.is_true().unwrap_or(false),
+            None => false,
+        };
         Ok(Self {
             item_validator,
             name,
             min_length: schema.get_as(pyo3::intern!(schema.py(), "min_length"))?,
             max_length: schema.get_as(pyo3::intern!(schema.py(), "max_length"))?,
+            hide_input: hide_input,
         }
         .into())
     }
@@ -56,13 +66,14 @@ impl Validator for GeneratorValidator {
         let validator = self
             .item_validator
             .as_ref()
-            .map(|v| InternalValidator::new(py, "ValidatorIterator", v, definitions, extra, recursion_guard));
+            .map(|v| InternalValidator::new(py, "ValidatorIterator", v, definitions, extra, recursion_guard, self.hide_input));
 
         let v_iterator = ValidatorIterator {
             iterator,
             validator,
             min_length: self.min_length,
             max_length: self.max_length,
+            hide_input: self.hide_input,
         };
         Ok(v_iterator.into_py(py))
     }
@@ -98,6 +109,7 @@ struct ValidatorIterator {
     validator: Option<InternalValidator>,
     min_length: Option<usize>,
     max_length: Option<usize>,
+    hide_input: bool,
 }
 
 #[pymethods]
@@ -109,6 +121,7 @@ impl ValidatorIterator {
     fn __next__(mut slf: PyRefMut<'_, Self>, py: Python) -> PyResult<Option<PyObject>> {
         let min_length = slf.min_length;
         let max_length = slf.max_length;
+        let hide_input = slf.hide_input;
         let Self {
             validator, iterator, ..
         } = &mut *slf;
@@ -133,6 +146,7 @@ impl ValidatorIterator {
                                         ErrorMode::Python,
                                         val_error,
                                         None,
+                                        hide_input,
                                     ));
                                 }
                             }
@@ -157,6 +171,7 @@ impl ValidatorIterator {
                                     ErrorMode::Python,
                                     val_error,
                                     None,
+                                    hide_input,
                                 ));
                             }
                         }
@@ -203,6 +218,7 @@ pub struct InternalValidator {
     self_instance: Option<PyObject>,
     recursion_guard: RecursionGuard,
     validation_mode: InputType,
+    hide_input: bool,
 }
 
 impl fmt::Debug for InternalValidator {
@@ -219,6 +235,7 @@ impl InternalValidator {
         definitions: &[CombinedValidator],
         extra: &Extra,
         recursion_guard: &RecursionGuard,
+        hide_input: bool,
     ) -> Self {
         Self {
             name: name.to_string(),
@@ -230,6 +247,7 @@ impl InternalValidator {
             self_instance: extra.self_instance.map(|d| d.into_py(py)),
             recursion_guard: recursion_guard.clone(),
             validation_mode: extra.mode,
+            hide_input: hide_input,
         }
     }
 
@@ -261,7 +279,7 @@ impl InternalValidator {
                 &mut self.recursion_guard,
             )
             .map_err(|e| {
-                ValidationError::from_val_error(py, self.name.to_object(py), ErrorMode::Python, e, outer_location)
+                ValidationError::from_val_error(py, self.name.to_object(py), ErrorMode::Python, e, outer_location, self.hide_input)
             })
     }
 
@@ -286,7 +304,7 @@ impl InternalValidator {
         self.validator
             .validate(py, input, &extra, &self.definitions, &mut self.recursion_guard)
             .map_err(|e| {
-                ValidationError::from_val_error(py, self.name.to_object(py), ErrorMode::Python, e, outer_location)
+                ValidationError::from_val_error(py, self.name.to_object(py), ErrorMode::Python, e, outer_location, self.hide_input)
             })
     }
 }

src/validators/mod.rs

@@ -65,6 +65,7 @@ pub struct SchemaValidator {
     schema: PyObject,
     #[pyo3(get)]
     title: PyObject,
+    hide_input: bool,
 }
 
 #[pymethods]
@@ -90,11 +91,20 @@ impl SchemaValidator {
             Some(t) => t.into_py(py),
             None => validator.get_name().into_py(py),
         };
+        let config_hide_input = match config {
+            Some(c) => c.get_item("hide_input_in_errors"),
+            None => None,
+        };
+        let hide_input = match config_hide_input {
+            Some(t) => t.is_true().unwrap_or(false),
+            None => false,
+        };
         Ok(Self {
             validator,
             definitions,
             schema: schema.into_py(py),
             title,
+            hide_input: hide_input,
         })
     }
 
@@ -227,7 +237,7 @@ impl SchemaValidator {
     }
 
     fn prepare_validation_err(&self, py: Python, error: ValError, error_mode: ErrorMode) -> PyErr {
-        ValidationError::from_val_error(py, self.title.clone_ref(py), error_mode, error, None)
+        ValidationError::from_val_error(py, self.title.clone_ref(py), error_mode, error, None, self.hide_input)
     }
 }
 
@@ -283,6 +293,7 @@ impl<'py> SelfValidator<'py> {
             definitions,
             schema: py.None(),
             title: "Self Schema".into_py(py),
+            hide_input: false,
         })
     }
 }