refactor: parse bytes

Author: JeanArhancet

src/input/return_enums.rs

@@ -809,6 +809,13 @@ impl<'a> From<&'a PyBytes> for EitherBytes<'a> {
 }
 
 impl<'a> EitherBytes<'a> {
+    pub fn as_slice(&'a self) -> &[u8] {
+        match self {
+            EitherBytes::Cow(bytes) => bytes,
+            EitherBytes::Py(py_bytes) => py_bytes.as_bytes(),
+        }
+    }
+
     pub fn len(&'a self) -> PyResult<usize> {
         match self {
             EitherBytes::Cow(bytes) => Ok(bytes.len()),

src/validators/uuid.rs

@@ -1,7 +1,8 @@
+use std::str::from_utf8;
+
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
-use pyo3::types::PyBytes;
 use pyo3::types::{PyDict, PyType};
 use uuid::Uuid;
 
@@ -109,7 +110,7 @@ impl Validator for UuidValidator {
                 input,
             ))
         } else {
-            let uuid = self.get_uuid(py, input)?;
+            let uuid = self.get_uuid(input)?;
             self.create_py_uuid(py, class, &uuid)
         }
     }
@@ -132,7 +133,7 @@ impl Validator for UuidValidator {
 }
 
 impl UuidValidator {
-    fn get_uuid<'s, 'data>(&'s self, py: Python<'data>, input: &'data impl Input<'data>) -> ValResult<'data, Uuid> {
+    fn get_uuid<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValResult<'data, Uuid> {
         let uuid = match input.exact_str().ok() {
             Some(either_string) => {
                 let cow = either_string.as_cow()?;
@@ -144,10 +145,17 @@ impl UuidValidator {
                 let either_bytes = input
                     .validate_bytes(true)
                     .map_err(|_| ValError::new(ErrorType::UuidType, input))?;
-                let py_object = either_bytes.into_py(py);
-                let py_bytes = py_object.downcast::<PyBytes>(py)?;
-                Uuid::from_slice(py_bytes.as_bytes())
-                    .map_err(|e| ValError::new(ErrorType::UuidParsing { error: e.to_string() }, input))?
+                let bytes_slice = either_bytes.as_slice();
+                'parse: {
+                    // Try parsing as utf8, but don't care if it fails
+                    if let Ok(utf8_str) = from_utf8(bytes_slice) {
+                        if let Ok(uuid) = Uuid::parse_str(utf8_str) {
+                            break 'parse uuid;
+                        }
+                    }
+                    Uuid::from_slice(bytes_slice)
+                        .map_err(|e| ValError::new(ErrorType::UuidParsing { error: e.to_string() }, input))?
+                }
             }
         };
 

tests/validators/test_uuid.py

@@ -25,6 +25,7 @@
         ('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11')),
         (b'\x12\x34\x56\x78' * 4, UUID('12345678-1234-5678-1234-567812345678')),
         (b'\x00\x00\x00\x00' * 4, UUID('00000000-0000-0000-0000-000000000000')),
+        (b'ebcdab58-6eb8-46fb-a190-d07a33e9eac8', UUID('ebcdab58-6eb8-46fb-a190-d07a33e9eac8')),
         (UUID('12345678-1234-5678-1234-567812345678'), UUID('12345678-1234-5678-1234-567812345678')),
         (UUID('550e8400-e29b-41d4-a716-446655440000'), UUID('550e8400-e29b-41d4-a716-446655440000')),
         # Invalid UUIDs