Update src/validators/uuid.rs

Co-authored-by: David Hewitt <[email protected]>

Author: JeanArhancet

python/pydantic_core/core_schema.py

@@ -3905,7 +3905,6 @@ def definition_reference_schema(
     'url_too_long',
     'url_scheme',
     'uuid_type',
-    'uuid_exact_type',
     'uuid_parsing',
     'uuid_version_mismatch',
 ]

src/errors/types.rs

@@ -310,9 +310,6 @@ pub enum ErrorType {
     },
     // UUID errors,
     UuidType,
-    UuidExactType {
-        class_name: String,
-    },
     UuidParsing {
         error: String,
     },
@@ -463,7 +460,6 @@ impl ErrorType {
             Self::UrlSyntaxViolation { .. } => extract_context!(Cow::Owned, UrlSyntaxViolation, ctx, error: String),
             Self::UrlTooLong { .. } => extract_context!(UrlTooLong, ctx, max_length: usize),
             Self::UrlScheme { .. } => extract_context!(UrlScheme, ctx, expected_schemes: String),
-            Self::UuidExactType { .. } => extract_context!(UuidExactType, ctx, class_name: String),
             Self::UuidParsing { .. } => extract_context!(UuidParsing, ctx, error: String),
             Self::UuidVersionMismatch { .. } => {
                 extract_context!(UuidVersionMismatch, ctx, version: usize, schema_version: usize)
@@ -572,7 +568,6 @@ impl ErrorType {
             Self::UrlSyntaxViolation {..} => "Input violated strict URL syntax rules, {error}",
             Self::UrlTooLong {..} => "URL should have at most {max_length} characters",
             Self::UrlScheme {..} => "URL scheme should be {expected_schemes}",
-            Self::UuidExactType { .. } => "Input should be an instance of {class_name}",
             Self::UuidType => "UUID input should be a string, bytes or UUID object",
             Self::UuidParsing { .. } => "Input should be a valid UUID, {error}",
             Self::UuidVersionMismatch { .. } => "UUID version {version} does not match expected version: {schema_version}"
@@ -696,7 +691,6 @@ impl ErrorType {
             Self::UrlSyntaxViolation { error } => render!(tmpl, error),
             Self::UrlTooLong { max_length } => to_string_render!(tmpl, max_length),
             Self::UrlScheme { expected_schemes } => render!(tmpl, expected_schemes),
-            Self::UuidExactType { class_name } => render!(tmpl, class_name),
             Self::UuidParsing { error } => render!(tmpl, error),
             Self::UuidVersionMismatch {
                 version,
@@ -762,7 +756,6 @@ impl ErrorType {
             Self::UrlSyntaxViolation { error } => py_dict!(py, error),
             Self::UrlTooLong { max_length } => py_dict!(py, max_length),
             Self::UrlScheme { expected_schemes } => py_dict!(py, expected_schemes),
-            Self::UuidExactType { class_name } => py_dict!(py, class_name),
 
             Self::UuidParsing { error } => py_dict!(py, error),
             Self::UuidVersionMismatch {

src/serializers/shared.rs

@@ -255,6 +255,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::Recursive(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::TuplePositional(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::TupleVariable(inner) => inner.py_gc_traverse(visit),
+            CombinedSerializer::Uuid(inner) => inner.py_gc_traverse(visit),
         }
     }
 }

src/serializers/type_serializers/uuid.rs

@@ -17,6 +17,8 @@ pub(crate) fn uuid_to_string(py_uuid: &PyAny) -> PyResult<String> {
 #[derive(Debug, Clone)]
 pub struct UuidSerializer;
 
+impl_py_gc_traverse!(UuidSerializer {});
+
 impl BuildSerializer for UuidSerializer {
     const EXPECTED_TYPE: &'static str = "uuid";
 

src/validators/uuid.rs

@@ -80,6 +80,8 @@ impl BuildValidator for UuidValidator {
     }
 }
 
+impl_py_gc_traverse!(UuidValidator {});
+
 impl Validator for UuidValidator {
     fn validate<'s, 'data>(
         &'s self,
@@ -107,8 +109,8 @@ impl Validator for UuidValidator {
             Ok(py_input.to_object(py))
         } else if extra.strict.unwrap_or(self.strict) && input.is_python() {
             Err(ValError::new(
-                ErrorType::UuidExactType {
-                    class_name: self.get_name().to_string(),
+                ErrorType::IsInstanceOf {
+                    class: class.name().unwrap_or("UUID").to_string(),
                 },
                 input,
             ))

tests/test_errors.py

@@ -282,7 +282,6 @@ def f(input_value, info):
     ('url_syntax_violation', 'Input violated strict URL syntax rules, Foobar', {'error': 'Foobar'}),
     ('url_too_long', 'URL should have at most 42 characters', {'max_length': 42}),
     ('url_scheme', 'URL scheme should be "foo", "bar" or "spam"', {'expected_schemes': '"foo", "bar" or "spam"'}),
-    ('uuid_exact_type', 'Input should be an instance of Foobar', {'class_name': 'Foobar'}),
     ('uuid_type', 'UUID input should be a string, bytes or UUID object', None),
     ('uuid_parsing', 'Input should be a valid UUID, Foobar', {'error': 'Foobar'}),
     (

tests/validators/test_uuid.py

@@ -89,9 +89,9 @@ def test_uuid(input_value, expected):
     'input_value,expected',
     [
         (UUID('12345678-1234-5678-1234-567812345678'), UUID('12345678-1234-5678-1234-567812345678')),
-        ('12345678-1234-5678-1234-567812345678', Err('Input should be an instance of uuid [type=uuid_exact_type,')),
-        (b'12345678-1234-5678-1234-567812345678', Err('Input should be an instance of uuid [type=uuid_exact_type,')),
-        (1654646400, Err('Input should be an instance of uuid [type=uuid_exact_type')),
+        ('12345678-1234-5678-1234-567812345678', Err('Input should be an instance of UUID [type=is_instance_of,')),
+        (b'12345678-1234-5678-1234-567812345678', Err('Input should be an instance of UUID [type=is_instance_of,')),
+        (1654646400, Err('Input should be an instance of UUID [type=is_instance_of')),
     ],
 )
 def test_uuid_strict(input_value, expected):