Logic for instances of subclasses of strings (#294)

* prevent subclasses of str to strict string

* strict and lax, add tests

* one more test

Author: samuelcolvin

pydantic_core/core_schema.py

@@ -1036,6 +1036,7 @@ def json_schema(schema: CoreSchema | None = None, *, ref: str | None = None, ext
     'iterable_type',
     'iteration_error',
     'string_type',
+    'string_sub_type',
     'string_unicode',
     'string_too_short',
     'string_too_long',

src/errors/kinds.rs

@@ -131,6 +131,8 @@ pub enum ErrorKind {
     // string errors
     #[strum(message = "Input should be a valid string")]
     StringType,
+    #[strum(message = "Input should be a string, not an instance of a subclass of str")]
+    StringSubType,
     #[strum(message = "Input should be a valid string, unable to parse raw data as a unicode string")]
     StringUnicode,
     #[strum(message = "String should have at least {min_length} characters")]

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};
+use pyo3::{intern, AsPyPointer, PyTypeInfo};
 
 use crate::errors::{py_err_string, ErrorKind, InputValue, LocItem, ValError, ValResult};
 
@@ -142,15 +142,25 @@ impl<'a> Input<'a> for PyAny {
 
     fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
         if let Ok(py_str) = self.cast_as::<PyString>() {
-            Ok(py_str.into())
+            if is_builtin_str(py_str) {
+                Ok(py_str.into())
+            } else {
+                Err(ValError::new(ErrorKind::StringSubType, self))
+            }
         } else {
             Err(ValError::new(ErrorKind::StringType, self))
         }
     }
 
     fn lax_str(&'a self) -> ValResult<EitherString<'a>> {
         if let Ok(py_str) = self.cast_as::<PyString>() {
-            Ok(py_str.into())
+            if is_builtin_str(py_str) {
+                Ok(py_str.into())
+            } else {
+                // force to a rust string to make sure behaviour is consistent whether or not we go via a
+                // rust string in StrConstrainedValidator - e.g. to_lower
+                Ok(py_string_str(py_str)?.into())
+            }
         } else if let Ok(bytes) = self.cast_as::<PyBytes>() {
             let str = match from_utf8(bytes.as_bytes()) {
                 Ok(s) => s,
@@ -672,3 +682,7 @@ fn import_type(py: Python, module: &str, attr: &str) -> PyResult<Py<PyType>> {
     let obj = py.import(module)?.getattr(attr)?;
     Ok(obj.cast_as::<PyType>()?.into())
 }
+
+fn is_builtin_str(py_str: &PyString) -> bool {
+    py_str.get_type().is(PyString::type_object(py_str.py()))
+}

tests/benchmarks/test_micro_benchmarks.py

@@ -212,12 +212,24 @@ class MyCoreModel:
 
 @pytest.mark.benchmark(group='string')
 def test_core_string_lax(benchmark):
-    validator = SchemaValidator({'type': 'str'})
+    validator = SchemaValidator(core_schema.string_schema())
     input_str = 'Hello ' * 20
 
+    assert validator.validate_python(input_str) == input_str
+
     benchmark(validator.validate_python, input_str)
 
 
+@pytest.mark.benchmark(group='string')
+def test_core_string_strict(benchmark):
+    validator = SchemaValidator(core_schema.string_schema(strict=True))
+    input_str = 'Hello ' * 20
+
+    assert validator.validate_python(input_str) == input_str
+
+    benchmark(validator.validate_python, 'foo')
+
+
 @pytest.fixture
 def recursive_model_data():
     data = {'width': -1}

tests/validators/test_string.py

@@ -186,3 +186,44 @@ def test_regex_error():
 def test_default_validator():
     v = SchemaValidator(core_schema.string_schema(strict=True, to_lower=False), {'str_strip_whitespace': False})
     assert plain_repr(v) == 'SchemaValidator(name="str",validator=Str(StrValidator{strict:true}),slots=[])'
+
+
+@pytest.fixture(scope='session', name='FruitEnum')
+def fruit_enum_fixture():
+    from enum import Enum
+
+    class FruitEnum(str, Enum):
+        pear = 'pear'
+        banana = 'banana'
+
+    return FruitEnum
+
+
+@pytest.mark.parametrize('kwargs', [{}, {'to_lower': True}], ids=repr)
+def test_strict_subclass(FruitEnum, kwargs):
+    v = SchemaValidator(core_schema.string_schema(strict=True, **kwargs))
+    assert v.validate_python('foobar') == 'foobar'
+    with pytest.raises(ValidationError, match='kind=string_type,'):
+        v.validate_python(b'foobar')
+    with pytest.raises(ValidationError, match='kind=string_sub_type,') as exc_info:
+        v.validate_python(FruitEnum.pear)
+    # insert_assert(exc_info.value.errors())
+    assert exc_info.value.errors() == [
+        {
+            'kind': 'string_sub_type',
+            'loc': [],
+            'message': 'Input should be a string, not an instance of a subclass of str',
+            'input_value': FruitEnum.pear,
+        }
+    ]
+
+
+@pytest.mark.parametrize('kwargs', [{}, {'to_lower': True}], ids=repr)
+def test_lax_subclass(FruitEnum, kwargs):
+    v = SchemaValidator(core_schema.string_schema(**kwargs))
+    assert v.validate_python('foobar') == 'foobar'
+    assert v.validate_python(b'foobar') == 'foobar'
+    p = v.validate_python(FruitEnum.pear)
+    assert p == 'pear'
+    assert type(p) is str
+    assert repr(p) == "'pear'"