add name to function validators (#303)

Author: samuelcolvin

src/validators/function.rs

@@ -51,10 +51,16 @@ macro_rules! impl_build {
             ) -> PyResult<CombinedValidator> {
                 let py = schema.py();
                 let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, build_context)?;
-                let name = format!("{}[{}]", $name, validator.get_name());
+                let function = schema.get_as_req::<&PyAny>(intern!(py, "function"))?;
+                let name = format!(
+                    "{}[{}(), {}]",
+                    $name,
+                    function_name(function)?,
+                    validator.get_name()
+                );
                 Ok(Self {
                     validator: Box::new(validator),
-                    func: schema.get_as_req::<&PyAny>(intern!(py, "function"))?.into_py(py),
+                    func: function.into_py(py),
                     config: match config {
                         Some(c) => c.into(),
                         None => py.None(),
@@ -67,6 +73,13 @@ macro_rules! impl_build {
     };
 }
 
+fn function_name(f: &PyAny) -> PyResult<String> {
+    match f.getattr(intern!(f.py(), "__name__")) {
+        Ok(name) => name.extract(),
+        _ => f.repr()?.extract(),
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct FunctionBeforeValidator {
     validator: Box<CombinedValidator>,
@@ -150,17 +163,20 @@ impl Validator for FunctionAfterValidator {
 pub struct FunctionPlainValidator {
     func: PyObject,
     config: PyObject,
+    name: String,
 }
 
 impl FunctionPlainValidator {
     pub fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
         let py = schema.py();
+        let function = schema.get_as_req::<&PyAny>(intern!(py, "function"))?;
         Ok(Self {
-            func: schema.get_as_req::<&PyAny>(intern!(py, "function"))?.into_py(py),
+            func: function.into_py(py),
             config: match config {
                 Some(c) => c.into(),
                 None => py.None(),
             },
+            name: format!("function-plain[{}()]", function_name(function)?),
         }
         .into())
     }
@@ -182,7 +198,7 @@ impl Validator for FunctionPlainValidator {
     }
 
     fn get_name(&self) -> &str {
-        "function-plain"
+        &self.name
     }
 }
 

tests/test_errors.py

@@ -52,16 +52,16 @@ def f(input_value, **kwargs):
 
 
 def test_pydantic_value_error_invalid_dict():
-    def f(input_value, **kwargs):
+    def my_function(input_value, **kwargs):
         raise PydanticCustomError('my_error', 'this is a custom error {foo}', {(): 'foobar'})
 
-    v = SchemaValidator({'type': 'function', 'mode': 'plain', 'function': f})
+    v = SchemaValidator({'type': 'function', 'mode': 'plain', 'function': my_function})
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(42)
 
     assert str(exc_info.value) == (
-        '1 validation error for function-plain\n'
+        '1 validation error for function-plain[my_function()]\n'
         "  (error rendering message: TypeError: 'tuple' object cannot be converted to 'PyString') "
         '[kind=my_error, input_value=42, input_type=int]'
     )

tests/validators/test_chain.py

@@ -94,7 +94,7 @@ def test_flatten():
     )
 
     assert validator.validate_python('input') == 'input-1-2-3'
-    assert validator.title == 'chain[function-plain,function-plain,function-plain]'
+    assert validator.title == 'chain[function-plain[<lambda>()],function-plain[<lambda>()],function-plain[<lambda>()]]'
 
 
 def test_chain_empty():
@@ -107,7 +107,7 @@ def test_chain_one():
         {'type': 'chain', 'steps': [{'type': 'function', 'mode': 'plain', 'function': lambda v, **kwargs: f'{v}-1'}]}
     )
     assert validator.validate_python('input') == 'input-1'
-    assert validator.title == 'function-plain'
+    assert validator.title == 'function-plain[<lambda>()]'
 
 
 def test_ask():

tests/validators/test_function.py

@@ -40,11 +40,11 @@ def f(input_value, **kwargs):
 
 
 def test_function_before_error():
-    def f(input_value, **kwargs):
+    def my_function(input_value, **kwargs):
         return input_value + 'x'
 
     v = SchemaValidator(
-        {'type': 'function', 'mode': 'before', 'function': f, 'schema': {'type': 'str', 'max_length': 5}}
+        {'type': 'function', 'mode': 'before', 'function': my_function, 'schema': {'type': 'str', 'max_length': 5}}
     )
 
     assert v.validate_python('1234') == '1234x'
@@ -59,6 +59,7 @@ def f(input_value, **kwargs):
             'context': {'max_length': 5},
         }
     ]
+    assert repr(exc_info.value).startswith('1 validation error for function-before[my_function(), constrained-str]\n')
 
 
 def test_function_before_error_model():

tests/validators/test_recursive.py

@@ -616,7 +616,7 @@ def f(input_value, **kwargs):
     assert exc_info.value.errors() == [
         {
             'kind': 'recursion_loop',
-            'loc': ['function-after[...]'],
+            'loc': ['function-after[f(), ...]'],
             'message': 'Recursion error - cyclic reference detected',
             'input_value': 'input value',
         },