add json_function to is_instance validator (#293)

Author: samuelcolvin

pydantic_core/core_schema.py

@@ -318,14 +318,22 @@ class IsInstanceSchema(TypedDict, total=False):
     type: Required[Literal['is-instance']]
     cls: Required[Type[Any]]
     json_types: Set[JsonType]
+    json_function: Callable[[Any], Any]
     ref: str
     extra: Any
 
 
 def is_instance_schema(
-    cls: Type[Any], *, json_types: Set[JsonType] | None = None, ref: str | None = None, extra: Any = None
+    cls: Type[Any],
+    *,
+    json_types: Set[JsonType] | None = None,
+    json_function: Callable[[Any], Any] | None = None,
+    ref: str | None = None,
+    extra: Any = None,
 ) -> IsInstanceSchema:
-    return dict_not_none(type='is-instance', cls=cls, json_types=json_types, ref=ref, extra=extra)
+    return dict_not_none(
+        type='is-instance', cls=cls, json_types=json_types, json_function=json_function, ref=ref, extra=extra
+    )
 
 
 class CallableSchema(TypedDict, total=False):

src/input/input_abstract.rs

@@ -9,11 +9,25 @@ use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherString};
 use super::{GenericArguments, GenericCollection, GenericIterator, GenericMapping, JsonInput};
 
+pub enum InputType {
+    Python,
+    Json,
+    String,
+}
+
+impl InputType {
+    pub fn is_json(&self) -> bool {
+        matches!(self, Self::Json)
+    }
+}
+
 /// all types have three methods: `validate_*`, `strict_*`, `lax_*`
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
 pub trait Input<'a>: fmt::Debug + ToPyObject {
+    fn get_type(&self) -> &'static InputType;
+
     fn as_loc_item(&self) -> LocItem;
 
     fn as_error_value(&'a self) -> InputValue<'a>;

src/input/input_json.rs

@@ -2,20 +2,24 @@ use pyo3::prelude::*;
 use pyo3::types::PyType;
 
 use crate::errors::{ErrorKind, InputValue, LocItem, ValError, ValResult};
-use crate::input::JsonType;
 
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
+use super::input_abstract::InputType;
 use super::parse_json::JsonArray;
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_int};
 use super::{
     EitherBytes, EitherString, EitherTimedelta, GenericArguments, GenericCollection, GenericIterator, GenericMapping,
-    Input, JsonArgs, JsonInput,
+    Input, JsonArgs, JsonInput, JsonType,
 };
 
 impl<'a> Input<'a> for JsonInput {
+    fn get_type(&self) -> &'static InputType {
+        &InputType::Json
+    }
+
     /// This is required by since JSON object keys are always strings, I don't think it can be called
     #[cfg_attr(has_no_coverage, no_coverage)]
     fn as_loc_item(&self) -> LocItem {
@@ -299,6 +303,10 @@ impl<'a> Input<'a> for JsonInput {
 
 /// Required for Dict keys so the string can behave like an Input
 impl<'a> Input<'a> for String {
+    fn get_type(&self) -> &'static InputType {
+        &InputType::String
+    }
+
     fn as_loc_item(&self) -> LocItem {
         self.to_string().into()
     }

src/input/input_python.rs

@@ -19,6 +19,7 @@ use super::datetime::{
     float_as_duration, float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime,
     EitherTime,
 };
+use super::input_abstract::InputType;
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_int};
 use super::{
     py_string_str, repr_string, EitherBytes, EitherString, EitherTimedelta, GenericArguments, GenericCollection,
@@ -55,6 +56,10 @@ macro_rules! extract_dict_iter {
 }
 
 impl<'a> Input<'a> for PyAny {
+    fn get_type(&self) -> &'static InputType {
+        &InputType::Python
+    }
+
     fn as_loc_item(&self) -> LocItem {
         if let Ok(py_str) = self.cast_as::<PyString>() {
             py_str.to_string_lossy().as_ref().into()

src/validators/is_instance.rs

@@ -7,12 +7,14 @@ use crate::errors::{ErrorKind, ValError, ValResult};
 use crate::input::{Input, JsonType};
 use crate::recursion_guard::RecursionGuard;
 
+use super::function::convert_err;
 use super::{BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
 pub struct IsInstanceValidator {
     class: Py<PyType>,
     json_types: u8,
+    json_function: Option<PyObject>,
     class_repr: String,
     name: String,
 }
@@ -25,16 +27,18 @@ impl BuildValidator for IsInstanceValidator {
         _config: Option<&PyDict>,
         _build_context: &mut BuildContext,
     ) -> PyResult<CombinedValidator> {
-        let class: &PyType = schema.get_as_req(intern!(schema.py(), "cls"))?;
+        let py = schema.py();
+        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
         let class_repr = class.name()?.to_string();
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, class_repr);
-        let json_types = match schema.get_as::<&PySet>(intern!(schema.py(), "json_types"))? {
+        let json_types = match schema.get_as::<&PySet>(intern!(py, "json_types"))? {
             Some(s) => JsonType::combine(s)?,
             None => 0,
         };
         Ok(Self {
             class: class.into(),
             json_types,
+            json_function: schema.get_item(intern!(py, "json_function")).map(|f| f.into_py(py)),
             class_repr,
             name,
         }
@@ -52,7 +56,16 @@ impl Validator for IsInstanceValidator {
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
         match input.is_instance(self.class.as_ref(py), self.json_types)? {
-            true => Ok(input.to_object(py)),
+            true => {
+                if input.get_type().is_json() {
+                    if let Some(ref json_function) = self.json_function {
+                        return json_function
+                            .call1(py, (input.to_object(py),))
+                            .map_err(|e| convert_err(py, e, input));
+                    }
+                }
+                Ok(input.to_object(py))
+            }
             false => Err(ValError::new(
                 ErrorKind::IsInstanceOf {
                     class: self.class_repr.clone(),

tests/validators/test_is_instance.py

@@ -1,3 +1,5 @@
+from collections import deque
+
 import pytest
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
@@ -183,3 +185,15 @@ def test_json_mask():
     assert 'json_types:0' in plain_repr(SchemaValidator(core_schema.is_instance_schema(str, json_types=set())))
     v = SchemaValidator(core_schema.is_instance_schema(str, json_types={'list', 'dict'}))
     assert 'json_types:6' in plain_repr(v)  # 2 + 4
+
+
+def test_json_function():
+    v = SchemaValidator(core_schema.is_instance_schema(deque, json_types={'list'}, json_function=deque))
+    output = v.validate_python(deque([1, 2, 3]))
+    assert output == deque([1, 2, 3])
+    output = v.validate_json('[1, 2, 3]')
+    assert output == deque([1, 2, 3])
+    with pytest.raises(ValidationError, match=r'Input should be an instance of deque \[kind=is_instance_of,'):
+        v.validate_python([1, 2, 3])
+    with pytest.raises(ValidationError, match=r'Input should be an instance of deque \[kind=is_instance_of,'):
+        v.validate_json('{"1": 2}')