Allow Sequence and tuple to is_instance validator (#299)

* allow Sequence and Tuple to is_instance validator

* rename to input_is_instance

* repr tests and type hints

* add cls_repr argument to isinstance validator

Author: samuelcolvin

pydantic_core/core_schema.py

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

src/input/input_abstract.rs

@@ -47,7 +47,8 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         None
     }
 
-    fn is_instance(&self, class: &PyType, json_mask: u8) -> PyResult<bool>;
+    // input_ prefix to differentiate from the function on PyAny
+    fn input_is_instance(&self, class: &PyAny, json_mask: u8) -> PyResult<bool>;
 
     fn callable(&self) -> bool {
         false

src/input/input_json.rs

@@ -1,5 +1,4 @@
 use pyo3::prelude::*;
-use pyo3::types::PyType;
 
 use crate::errors::{ErrorKind, InputValue, LocItem, ValError, ValResult};
 
@@ -38,7 +37,7 @@ impl<'a> Input<'a> for JsonInput {
         matches!(self, JsonInput::Null)
     }
 
-    fn is_instance(&self, _class: &PyType, json_mask: u8) -> PyResult<bool> {
+    fn input_is_instance(&self, _class: &PyAny, json_mask: u8) -> PyResult<bool> {
         if json_mask == 0 {
             Ok(false)
         } else {
@@ -320,7 +319,7 @@ impl<'a> Input<'a> for String {
         false
     }
 
-    fn is_instance(&self, _class: &PyType, json_mask: u8) -> PyResult<bool> {
+    fn input_is_instance(&self, _class: &PyAny, json_mask: u8) -> PyResult<bool> {
         if json_mask == 0 {
             Ok(false)
         } else {

src/input/input_python.rs

@@ -10,7 +10,7 @@ use pyo3::types::{
 };
 #[cfg(not(PyPy))]
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
-use pyo3::{intern, AsPyPointer, PyTypeInfo};
+use pyo3::{ffi, intern, AsPyPointer, PyTypeInfo};
 
 use crate::errors::{py_err_string, ErrorKind, InputValue, LocItem, ValError, ValResult};
 
@@ -22,8 +22,8 @@ use super::datetime::{
 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,
-    GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
+    py_error_on_minusone, py_string_str, repr_string, EitherBytes, EitherString, EitherTimedelta, GenericArguments,
+    GenericCollection, GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
 };
 
 /// Extract generators and deques into a `GenericCollection`
@@ -93,8 +93,12 @@ impl<'a> Input<'a> for PyAny {
         self.getattr(name).ok()
     }
 
-    fn is_instance(&self, class: &PyType, _json_mask: u8) -> PyResult<bool> {
-        self.is_instance(class)
+    fn input_is_instance(&self, class: &PyAny, _json_mask: u8) -> PyResult<bool> {
+        // See PyO3/pyo3#2694 - we can't use `is_instance` here since it requires PyType,
+        // and some check objects are not types, this logic is lifted from `is_instance` in PyO3
+        let result = unsafe { ffi::PyObject_IsInstance(self.as_ptr(), class.as_ptr()) };
+        py_error_on_minusone(self.py(), result)?;
+        Ok(result == 1)
     }
 
     fn callable(&self) -> bool {

src/input/mod.rs

@@ -1,3 +1,5 @@
+use std::os::raw::c_int;
+
 use pyo3::prelude::*;
 
 mod datetime;
@@ -19,3 +21,12 @@ pub use return_enums::{
 pub fn repr_string(v: &PyAny) -> PyResult<String> {
     v.repr()?.extract()
 }
+
+// Defined here as it's not exported by pyo3
+pub fn py_error_on_minusone(py: Python<'_>, result: c_int) -> PyResult<()> {
+    if result != -1 {
+        Ok(())
+    } else {
+        Err(PyErr::fetch(py))
+    }
+}

src/validators/is_instance.rs

@@ -2,7 +2,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet, PyType};
 
-use crate::build_tools::SchemaDict;
+use crate::build_tools::{py_err, SchemaDict};
 use crate::errors::{ErrorKind, ValError, ValResult};
 use crate::input::{Input, JsonType};
 use crate::recursion_guard::RecursionGuard;
@@ -12,7 +12,7 @@ use super::{BuildContext, BuildValidator, CombinedValidator, Extra, Validator};
 
 #[derive(Debug, Clone)]
 pub struct IsInstanceValidator {
-    class: Py<PyType>,
+    class: PyObject,
     json_types: u8,
     json_function: Option<PyObject>,
     class_repr: String,
@@ -28,8 +28,23 @@ impl BuildValidator for IsInstanceValidator {
         _build_context: &mut BuildContext,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let class_repr = class.name()?.to_string();
+        let cls_key = intern!(py, "cls");
+        let class: &PyAny = schema.get_as_req(cls_key)?;
+
+        // test that class works with isinstance to avoid errors at call time, reuse cls_key since it doesn't
+        // matter what object is being checked
+        let test_value: &PyAny = cls_key.as_ref();
+        if test_value.input_is_instance(class, 0).is_err() {
+            return py_err!("'cls' must be valid as the first argument to 'isinstance'");
+        }
+
+        let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
+            Some(s) => s,
+            None => match class.extract::<&PyType>() {
+                Ok(t) => t.name()?.to_string(),
+                Err(_) => class.repr()?.extract()?,
+            },
+        };
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, class_repr);
         let json_types = match schema.get_as::<&PySet>(intern!(py, "json_types"))? {
             Some(s) => JsonType::combine(s)?,
@@ -55,7 +70,7 @@ impl Validator for IsInstanceValidator {
         _slots: &'data [CombinedValidator],
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        match input.is_instance(self.class.as_ref(py), self.json_types)? {
+        match input.input_is_instance(self.class.as_ref(py), self.json_types)? {
             true => {
                 if input.get_type().is_json() {
                     if let Some(ref json_function) = self.json_function {

src/validators/new_class.rs

@@ -1,5 +1,4 @@
 use std::cmp::Ordering;
-use std::os::raw::c_int;
 use std::ptr::null_mut;
 
 use pyo3::conversion::AsPyPointer;
@@ -10,7 +9,7 @@ use pyo3::{ffi, intern};
 
 use crate::build_tools::{py_err, SchemaDict};
 use crate::errors::{ErrorKind, ValError, ValResult};
-use crate::input::Input;
+use crate::input::{py_error_on_minusone, Input};
 use crate::questions::Question;
 use crate::recursion_guard::RecursionGuard;
 
@@ -159,23 +158,13 @@ where
     let attr_name = attr_name.to_object(py);
     let value = value.to_object(py);
     unsafe {
-        error_on_minusone(
+        py_error_on_minusone(
             py,
             ffi::PyObject_GenericSetAttr(obj.as_ptr(), attr_name.as_ptr(), value.as_ptr()),
         )
     }
 }
 
-// Defined here as it's not exported by pyo3
-#[inline]
-fn error_on_minusone(py: Python<'_>, result: c_int) -> PyResult<()> {
-    if result != -1 {
-        Ok(())
-    } else {
-        Err(PyErr::fetch(py))
-    }
-}
-
 fn build_config<'a>(
     py: Python<'a>,
     schema: &'a PyDict,

tests/validators/test_is_instance.py

@@ -1,3 +1,4 @@
+import typing
 from collections import deque
 
 import pytest
@@ -69,7 +70,7 @@ def test_is_instance_cases(schema_class, input_val, value):
 
 @pytest.mark.parametrize('input_cls', [123, 'foo', Foo(), [], {1: 2}])
 def test_is_instance_invalid(input_cls):
-    with pytest.raises(SchemaError, match="object cannot be converted to 'PyType'"):
+    with pytest.raises(SchemaError, match="SchemaError: 'cls' must be valid as the first argument to 'isinstance'"):
         SchemaValidator({'type': 'is-instance', 'cls': input_cls})
 
 
@@ -197,3 +198,28 @@ def test_json_function():
         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}')
+
+
+def test_is_instance_sequence():
+    v = SchemaValidator(core_schema.is_instance_schema(typing.Sequence))
+    assert v.isinstance_python(1) is False
+    assert v.isinstance_python([1]) is True
+
+    with pytest.raises(ValidationError, match=r'Input should be an instance of typing.Sequence \[kind=is_instance_of,'):
+        v.validate_python(1)
+
+
+def test_is_instance_tuple():
+    v = SchemaValidator(core_schema.is_instance_schema((int, str)))
+    assert v.isinstance_python(1) is True
+    assert v.isinstance_python('foobar') is True
+    assert v.isinstance_python([1]) is False
+    with pytest.raises(ValidationError, match=r"Input should be an instance of \(<class 'int'>, <class 'str'>\)"):
+        v.validate_python([1])
+
+
+def test_class_repr():
+    v = SchemaValidator(core_schema.is_instance_schema(int, cls_repr='Foobar'))
+    assert v.validate_python(1) == 1
+    with pytest.raises(ValidationError, match=r'Input should be an instance of Foobar \[kind=is_instance_of,'):
+        v.validate_python('1')