allow bytes and bytearray to json

Author: samuelcolvin

pydantic_core/_pydantic_core.pyi

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Union
 
 from pydantic_core._types import Schema
 
@@ -8,8 +8,8 @@ class SchemaValidator:
     def __init__(self, schema: Schema) -> None: ...
     def validate_python(self, input: Any) -> Any: ...
     def isinstance_python(self, input: Any) -> bool: ...
-    def validate_json(self, input: str) -> Any: ...
-    def isinstance_json(self, input: str) -> bool: ...
+    def validate_json(self, input: Union[str, bytes]) -> Any: ...
+    def isinstance_json(self, input: Union[str, bytes]) -> bool: ...
     def validate_assignment(self, field: str, input: Any, data: Dict[str, Any]) -> Dict[str, Any]: ...
 
 class SchemaError(ValueError):

src/validators/mod.rs

@@ -2,10 +2,9 @@ use std::fmt::Debug;
 
 use enum_dispatch::enum_dispatch;
 
-use pyo3::exceptions::PyRecursionError;
+use pyo3::exceptions::{PyRecursionError, PyTypeError};
 use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict};
-use serde_json::from_str as parse_json;
+use pyo3::types::{PyAny, PyByteArray, PyBytes, PyDict, PyString};
 
 use crate::build_tools::{py_error, SchemaDict, SchemaError};
 use crate::errors::{ErrorKind, ValError, ValLineError, ValResult, ValidationError};
@@ -99,8 +98,8 @@ impl SchemaValidator {
         }
     }
 
-    pub fn validate_json(&self, py: Python, input: String) -> PyResult<PyObject> {
-        match parse_json::<JsonInput>(&input) {
+    pub fn validate_json(&self, py: Python, input: &PyAny) -> PyResult<PyObject> {
+        match parse_json(input)? {
             Ok(input) => {
                 let r = self.validator.validate(
                     py,
@@ -112,15 +111,15 @@ impl SchemaValidator {
                 r.map_err(|e| self.prepare_validation_err(py, e))
             }
             Err(e) => {
-                let line_err = ValLineError::new(ErrorKind::InvalidJson { error: e.to_string() }, &input);
+                let line_err = ValLineError::new(ErrorKind::InvalidJson { error: e.to_string() }, input);
                 let err = ValError::LineErrors(vec![line_err]);
                 Err(self.prepare_validation_err(py, err))
             }
         }
     }
 
-    pub fn isinstance_json(&self, py: Python, input: String) -> PyResult<bool> {
-        match parse_json::<JsonInput>(&input) {
+    pub fn isinstance_json(&self, py: Python, input: &PyAny) -> PyResult<bool> {
+        match parse_json(input)? {
             Ok(input) => {
                 match self.validator.validate(
                     py,
@@ -164,6 +163,18 @@ impl SchemaValidator {
     }
 }
 
+fn parse_json(input: &PyAny) -> PyResult<serde_json::Result<JsonInput>> {
+    if let Ok(py_bytes) = input.cast_as::<PyBytes>() {
+        Ok(serde_json::from_slice(py_bytes.as_bytes()))
+    } else if let Ok(py_str) = input.cast_as::<PyString>() {
+        Ok(serde_json::from_str(&py_str.to_string_lossy()))
+    } else if let Ok(py_byte_array) = input.cast_as::<PyByteArray>() {
+        Ok(serde_json::from_slice(unsafe { py_byte_array.as_bytes() }))
+    } else {
+        Err(PyTypeError::new_err("JSON input must be str, bytes or bytearray"))
+    }
+}
+
 pub trait BuildValidator: Sized {
     const EXPECTED_TYPE: &'static str;
 

tests/test_json.py

@@ -12,6 +12,18 @@ def test_bool(input_value, output_value):
     assert v.validate_json(input_value) == output_value
 
 
+@pytest.mark.parametrize('input_value', ['[1, 2, 3]', b'[1, 2, 3]', bytearray(b'[1, 2, 3]')])
+def test_input_types(input_value):
+    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    assert v.validate_json(input_value) == [1, 2, 3]
+
+
+def test_input_type_invalid():
+    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    with pytest.raises(TypeError, match='^JSON input must be str, bytes or bytearray$'):
+        v.validate_json([])
+
+
 def test_null():
     assert SchemaValidator({'type': 'none'}).validate_json('null') is None