Function call (#218)

* capacity to call functions

* capacity to call functions

* renaming to new-class and call-function

* cleanup coverage

* more tests and fix coverage

* add typing tests

* rename call-function -> call

Author: samuelcolvin

pydantic_core/_types.py

@@ -109,8 +109,8 @@ class LiteralSchema(TypedDict):
     ref: NotRequired[str]
 
 
-class ModelClassSchema(TypedDict):
-    type: Literal['model-class']
+class NewClassSchema(TypedDict):
+    type: Literal['new-class']
     class_type: type
     schema: Schema
     strict: NotRequired[bool]
@@ -279,13 +279,13 @@ class CallableSchema(TypedDict):
     type: Literal['callable']
 
 
-class Parameter(TypedDict):
-    name: str
-    mode: Literal['positional_only', 'positional_or_keyword', 'keyword_only']
-    schema: Schema
-    default: NotRequired[Any]
-    default_factory: NotRequired[Callable[[], Any]]
-    alias: NotRequired[Union[str, List[Union[str, int]], List[List[Union[str, int]]]]]
+class Parameter(TypedDict, total=False):
+    name: Required[str]
+    mode: Literal['positional_only', 'positional_or_keyword', 'keyword_only']  # default positional_or_keyword
+    schema: Required[Schema]
+    default: Any
+    default_factory: Callable[[], Any]
+    alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
 
 
 class ArgumentsSchema(TypedDict, total=False):
@@ -297,6 +297,14 @@ class ArgumentsSchema(TypedDict, total=False):
     ref: str
 
 
+class CallSchema(TypedDict):
+    type: Literal['call']
+    function: Callable[..., Any]
+    arguments_schema: Schema
+    return_schema: NotRequired[Schema]
+    ref: NotRequired[str]
+
+
 # pydantic allows types to be defined via a simple string instead of dict with just `type`, e.g.
 # 'int' is equivalent to {'type': 'int'}, this only applies to schema types which do not have other required fields
 BareType = Literal[
@@ -335,7 +343,7 @@ class ArgumentsSchema(TypedDict, total=False):
     ListSchema,
     LiteralSchema,
     TypedDictSchema,
-    ModelClassSchema,
+    NewClassSchema,
     NoneSchema,
     NullableSchema,
     RecursiveReferenceSchema,
@@ -353,4 +361,5 @@ class ArgumentsSchema(TypedDict, total=False):
     IsInstanceSchema,
     CallableSchema,
     ArgumentsSchema,
+    CallSchema,
 ]

src/errors/line_error.rs

@@ -114,14 +114,6 @@ impl<'a> ValLineError<'a> {
         self.kind = kind;
         self
     }
-
-    pub fn into_new<'b>(self, py: Python) -> ValLineError<'b> {
-        ValLineError {
-            kind: self.kind,
-            location: self.location,
-            input_value: self.input_value.to_object(py).into(),
-        }
-    }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]

src/errors/validation_exception.rs

@@ -41,12 +41,11 @@ impl ValidationError {
 }
 
 // used to convert a validation error back to ValError for wrap functions
-impl<'a> From<ValidationError> for ValError<'a> {
-    fn from(val_error: ValidationError) -> Self {
-        val_error
-            .line_errors
+impl<'a> IntoPy<ValError<'a>> for ValidationError {
+    fn into_py(self, py: Python) -> ValError<'a> {
+        self.line_errors
             .into_iter()
-            .map(|e| e.into())
+            .map(|e| e.into_py(py))
             .collect::<Vec<_>>()
             .into()
     }
@@ -130,12 +129,12 @@ impl<'a> IntoPy<PyLineError> for ValLineError<'a> {
 }
 
 /// opposite of above, used to extract line errors from a validation error for wrap functions
-impl<'a> From<PyLineError> for ValLineError<'a> {
-    fn from(py_line_error: PyLineError) -> Self {
-        Self {
-            kind: py_line_error.kind,
-            location: py_line_error.location,
-            input_value: py_line_error.input_value.into(),
+impl<'a> IntoPy<ValLineError<'a>> for PyLineError {
+    fn into_py(self, _py: Python) -> ValLineError<'a> {
+        ValLineError {
+            kind: self.kind,
+            location: self.location,
+            input_value: self.input_value.into(),
         }
     }
 }

src/input/return_enums.rs

@@ -246,9 +246,9 @@ impl<'a> IntoPy<PyObject> for EitherString<'a> {
 }
 
 pub fn py_string_str(py_str: &PyString) -> ValResult<&str> {
-    py_str.to_str().map_err(|_| {
-        ValError::new_custom_input(ErrorKind::StrUnicode, InputValue::PyObject(py_str.into_py(py_str.py())))
-    })
+    py_str
+        .to_str()
+        .map_err(|_| ValError::new_custom_input(ErrorKind::StrUnicode, InputValue::PyAny(py_str as &PyAny)))
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]

src/validators/arguments.rs

@@ -53,7 +53,9 @@ impl BuildValidator for ArgumentsValidator {
             let arg: &PyDict = arg.cast_as()?;
 
             let name: String = arg.get_as_req(intern!(py, "name"))?;
-            let mode: &str = arg.get_as_req(intern!(py, "mode"))?;
+            let mode = arg
+                .get_as::<&str>(intern!(py, "mode"))?
+                .unwrap_or("positional_or_keyword");
             let positional = mode == "positional_only" || mode == "positional_or_keyword";
             if positional {
                 positional_params_count = arg_index + 1;

src/validators/call.rs

@@ -0,0 +1,88 @@
+use pyo3::exceptions::PyTypeError;
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyTuple};
+
+use crate::build_tools::SchemaDict;
+use crate::errors::ValResult;
+use crate::input::Input;
+use crate::recursion_guard::RecursionGuard;
+
+use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
+
+#[derive(Debug, Clone)]
+pub struct CallValidator {
+    function: PyObject,
+    arguments_validator: Box<CombinedValidator>,
+    return_validator: Option<Box<CombinedValidator>>,
+    name: String,
+}
+
+impl BuildValidator for CallValidator {
+    const EXPECTED_TYPE: &'static str = "call";
+
+    fn build(
+        schema: &PyDict,
+        config: Option<&PyDict>,
+        build_context: &mut BuildContext,
+    ) -> PyResult<CombinedValidator> {
+        let py = schema.py();
+
+        let arguments_schema: &PyAny = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let arguments_validator = Box::new(build_validator(arguments_schema, config, build_context)?);
+
+        let return_schema = schema.get_item(intern!(py, "return_schema"));
+        let return_validator = match return_schema {
+            Some(return_schema) => Some(Box::new(build_validator(return_schema, config, build_context)?)),
+            None => None,
+        };
+        let function: &PyAny = schema.get_as_req(intern!(py, "function"))?;
+        let function_name: &str = function.getattr(intern!(py, "__name__"))?.extract()?;
+        let name = format!("{}[{}]", Self::EXPECTED_TYPE, function_name);
+
+        Ok(Self {
+            function: function.to_object(py),
+            arguments_validator,
+            return_validator,
+            name,
+        }
+        .into())
+    }
+}
+
+impl Validator for CallValidator {
+    fn validate<'s, 'data>(
+        &'s self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        extra: &Extra,
+        slots: &'data [CombinedValidator],
+        recursion_guard: &'s mut RecursionGuard,
+    ) -> ValResult<'data, PyObject> {
+        let args = self
+            .arguments_validator
+            .validate(py, input, extra, slots, recursion_guard)
+            .map_err(|e| e.with_outer_location("arguments".into()))?;
+
+        let return_value = if let Ok((args, kwargs)) = args.extract::<(&PyTuple, &PyDict)>(py) {
+            self.function.call(py, args, Some(kwargs))?
+        } else if let Ok(kwargs) = args.cast_as::<PyDict>(py) {
+            self.function.call(py, (), Some(kwargs))?
+        } else {
+            let msg = "Arguments validator should return a tuple of (args, kwargs) or a dict of kwargs";
+            return Err(PyTypeError::new_err(msg).into());
+        };
+
+        if let Some(return_validator) = &self.return_validator {
+            return_validator
+                .validate(py, return_value.into_ref(py), extra, slots, recursion_guard)
+                .map_err(|e| e.with_outer_location("return-value".into()))
+        } else {
+            Ok(return_value.to_object(py))
+        }
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+}

src/validators/function.rs

@@ -87,22 +87,9 @@ impl Validator for FunctionBeforeValidator {
             .func
             .call(py, (input.to_object(py),), kwargs)
             .map_err(|e| convert_err(py, e, input))?;
-        // maybe there's some way to get the PyAny here and explicitly tell rust it should have lifespan 'a?
-        let new_input: &PyAny = value.as_ref(py);
-        match self.validator.validate(py, new_input, extra, slots, recursion_guard) {
-            Ok(v) => Ok(v),
-            Err(ValError::InternalErr(err)) => Err(ValError::InternalErr(err)),
-            Err(ValError::LineErrors(line_errors)) => {
-                // we have to be explicit about clone line errors to a new lifetime since new_input doesn't have
-                // the 'data lifetime
-                Err(ValError::LineErrors(
-                    line_errors
-                        .into_iter()
-                        .map(|line_error| line_error.into_new(py))
-                        .collect(),
-                ))
-            }
-        }
+
+        self.validator
+            .validate(py, value.into_ref(py), extra, slots, recursion_guard)
     }
 
     fn get_name(&self) -> &str {
@@ -308,7 +295,7 @@ fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> Val
         if let Ok(pydantic_value_error) = err.value(py).extract::<PydanticValueError>() {
             pydantic_value_error.into_val_error(input)
         } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
-            validation_error.into()
+            validation_error.into_py(py)
         } else {
             py_err_string!(err.value(py), ValueError, input)
         }

src/validators/mod.rs

@@ -17,6 +17,7 @@ mod any;
 mod arguments;
 mod bool;
 mod bytes;
+mod call;
 mod callable;
 mod date;
 mod datetime;
@@ -28,7 +29,7 @@ mod int;
 mod is_instance;
 mod list;
 mod literal;
-mod model_class;
+mod new_class;
 mod none;
 mod nullable;
 mod recursive;
@@ -314,7 +315,7 @@ pub fn build_validator<'a>(
         // nullables
         nullable::NullableValidator,
         // model classes
-        model_class::ModelClassValidator,
+        new_class::NewClassValidator,
         // strings
         string::StrValidator,
         // integers
@@ -335,6 +336,8 @@ pub fn build_validator<'a>(
         none::NoneValidator,
         // functions - before, after, plain & wrap
         function::FunctionBuilder,
+        // function call - validation around a function call
+        call::CallValidator,
         // recursive (self-referencing) models
         recursive::RecursiveRefValidator,
         // literals
@@ -408,7 +411,7 @@ pub enum CombinedValidator {
     // nullables
     Nullable(nullable::NullableValidator),
     // model classes
-    ModelClass(model_class::ModelClassValidator),
+    ModelClass(new_class::NewClassValidator),
     // strings
     Str(string::StrValidator),
     StrConstrained(string::StrConstrainedValidator),
@@ -436,6 +439,8 @@ pub enum CombinedValidator {
     FunctionAfter(function::FunctionAfterValidator),
     FunctionPlain(function::FunctionPlainValidator),
     FunctionWrap(function::FunctionWrapValidator),
+    // function call - validation around a function call
+    FunctionCall(call::CallValidator),
     // recursive (self-referencing) models
     Recursive(recursive::RecursiveContainerValidator),
     RecursiveRef(recursive::RecursiveRefValidator),

src/validators/model_class.rs renamed to src/validators/new_class.rs

@@ -16,7 +16,7 @@ use crate::recursion_guard::RecursionGuard;
 use super::{build_validator, BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
-pub struct ModelClassValidator {
+pub struct NewClassValidator {
     strict: bool,
     revalidate: bool,
     validator: Box<CombinedValidator>,
@@ -25,8 +25,8 @@ pub struct ModelClassValidator {
     expect_fields_set: bool,
 }
 
-impl BuildValidator for ModelClassValidator {
-    const EXPECTED_TYPE: &'static str = "model-class";
+impl BuildValidator for NewClassValidator {
+    const EXPECTED_TYPE: &'static str = "new-class";
 
     fn build(
         schema: &PyDict,
@@ -59,7 +59,7 @@ impl BuildValidator for ModelClassValidator {
     }
 }
 
-impl Validator for ModelClassValidator {
+impl Validator for NewClassValidator {
     fn validate<'s, 'data>(
         &'s self,
         py: Python<'data>,
@@ -106,7 +106,7 @@ impl Validator for ModelClassValidator {
     }
 }
 
-impl ModelClassValidator {
+impl NewClassValidator {
     fn create_class(&self, py: Python, model_dict: &PyAny, fields_set: Option<&PyAny>) -> PyResult<PyObject> {
         // based on the following but with the second argument of new_func set to an empty tuple as required
         // https://github.com/PyO3/pyo3/blob/d2caa056e9aacc46374139ef491d112cb8af1a25/src/pyclass_init.rs#L35-L77

tests/benchmarks/complete_schema.py

@@ -10,7 +10,7 @@ def wrap_function(input_value, *, validator, **kwargs):
         return f'Input {validator(input_value)} Changed'
 
     return {
-        'type': 'model-class',
+        'type': 'new-class',
         'class_type': MyModel,
         'config': {'strict': strict},
         'schema': {