feat: add uuid validator

Author: JeanArhancet

.DS_Store

@@ -43,6 +43,7 @@ idna = "0.3.0"
 base64 = "0.13.1"
 num-bigint = "0.4.3"
 python3-dll-a = "0.2.7"
+uuid = "1.3.4"
 
 [lib]
 name = "_pydantic_core"

Cargo.lock

@@ -73,6 +73,7 @@ class CoreConfig(TypedDict, total=False):
     # to construct error `loc`s, default True
     loc_by_alias: bool
     # whether instances of models and dataclasses (including subclass instances) should re-validate, default 'never'
+    # whether instances of models and dataclasses (including subclass instances) should re-validate, default 'never'
     revalidate_instances: Literal['always', 'never', 'subclass-instances']
     # whether to validate default values during validation, default False
     validate_default: bool
@@ -206,6 +207,7 @@ def field_name(self) -> str:
     'url',
     'multi-host-url',
     'json',
+    'uuid',
 ]
 
 
@@ -1187,6 +1189,24 @@ def callable_schema(
     return _dict_not_none(type='callable', ref=ref, metadata=metadata, serialization=serialization)
 
 
+class UuidSchema(TypedDict, total=False):
+    type: Required[Literal['uuid']]
+    version: Literal[1, 3, 4, 5]
+    ref: str
+    metadata: Any
+    serialization: SerSchema
+
+
+def uuid_schema(
+    *,
+    version: Literal[1, 3, 4, 5] | None = None,
+    ref: str | None = None,
+    metadata: Any = None,
+    serialization: SerSchema | None = None,
+) -> UuidSchema:
+    return _dict_not_none(type='uuid', ref=ref, version=version, metadata=metadata, serialization=serialization)
+
+
 class IncExSeqSerSchema(TypedDict, total=False):
     type: Required[Literal['include-exclude-sequence']]
     include: Set[int]
@@ -3688,6 +3708,7 @@ def definition_reference_schema(
         IsInstanceSchema,
         IsSubclassSchema,
         CallableSchema,
+        UuidSchema,
         ListSchema,
         TuplePositionalSchema,
         TupleVariableSchema,
@@ -3772,6 +3793,7 @@ def definition_reference_schema(
     'multi-host-url',
     'definitions',
     'definition-ref',
+    'uuid',
 ]
 
 CoreSchemaFieldType = Literal['model-field', 'dataclass-field', 'typed-dict-field', 'computed-field']
@@ -3867,6 +3889,9 @@ def definition_reference_schema(
     'url_syntax_violation',
     'url_too_long',
     'url_scheme',
+    'uuid_type',
+    'uuid_parsing',
+    'uuid_version_mismatch',
 ]
 
 

Cargo.toml

@@ -308,6 +308,18 @@ pub enum ErrorType {
     UrlScheme {
         expected_schemes: String,
     },
+    // UUID errors,
+    UuidType,
+    UuidExactType {
+        class_name: String,
+    },
+    UuidParsing {
+        error: String,
+    },
+    UuidVersionMismatch {
+        version: usize,
+        schema_version: usize,
+    },
 }
 
 macro_rules! render {
@@ -451,6 +463,11 @@ 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)
+            }
             _ => {
                 if ctx.is_some() {
                     py_err!(PyTypeError; "'{}' errors do not require context", value)
@@ -555,6 +572,11 @@ 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 or UUID object",
+            Self::UuidParsing { .. } => "Input should be a valid UUID, {error}",
+            Self::UuidVersionMismatch { .. } => "UUID version {version} doest not match expected version: {schema_version}"
+
         }
     }
 
@@ -674,6 +696,12 @@ 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,
+                schema_version,
+            } => to_string_render!(tmpl, version, schema_version),
             _ => Ok(tmpl.to_string()),
         }
     }
@@ -734,6 +762,13 @@ 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 {
+                version,
+                schema_version,
+            } => py_dict!(py, version, schema_version),
             _ => Ok(None),
         }
     }

python/pydantic_core/core_schema.py

@@ -1,4 +1,5 @@
 use std::fmt;
+use uuid::Uuid;
 
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};

src/errors/types.rs

@@ -257,6 +257,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorType::DateType, self)),
         }
     }
+
     // NO custom `lax_date` implementation, if strict_date fails, the validator will fallback to lax_datetime
     // then check there's no remainder
     #[cfg_attr(has_no_coverage, no_coverage)]

src/input/input_abstract.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::str::from_utf8;
+use uuid::Uuid;
 
 use pyo3::prelude::*;
 use pyo3::types::{

src/input/input_json.rs

@@ -5,6 +5,7 @@ use std::slice::Iter as SliceIter;
 use std::str::FromStr;
 
 use num_bigint::BigInt;
+use uuid::Uuid;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;

src/input/input_python.rs

@@ -187,6 +187,10 @@ pub(crate) fn infer_to_python_known(
                 let py_url: PyMultiHostUrl = value.extract()?;
                 py_url.__str__().into_py(py)
             }
+            ObType::Uuid => {
+                let v = value.getattr(intern!(py, "value"))?;
+                infer_to_python(v, include, exclude, extra)?.into_py(py)
+            }
             ObType::PydanticSerializable => serialize_with_serializer()?,
             ObType::Dataclass => serialize_dict(dataclass_to_dict(value)?)?,
             ObType::Enum => {
@@ -503,6 +507,10 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             }
             seq.end()
         }
+        ObType::Uuid => {
+            let s = value.str().map_err(py_err_se_err)?.to_str().map_err(py_err_se_err)?;
+            serializer.serialize_str(s)
+        }
         ObType::Path => {
             let s = value.str().map_err(py_err_se_err)?.to_str().map_err(py_err_se_err)?;
             serializer.serialize_str(s)
@@ -616,7 +624,7 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: &ObType, key: &'py PyAny, extra
             let k = key.getattr(intern!(key.py(), "value"))?;
             infer_json_key(k, extra)
         }
-        ObType::Path => Ok(key.str()?.to_string_lossy()),
+        ObType::Path | ObType::Uuid => Ok(key.str()?.to_string_lossy()),
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_key = fallback.call1((key,))?;

src/input/return_enums.rs

@@ -39,6 +39,8 @@ pub struct ObTypeLookup {
     // types from this package
     url: usize,
     multi_host_url: usize,
+    // uuid type
+    uuid: usize,
     // enum type
     enum_type: usize,
     // generator
@@ -83,6 +85,7 @@ impl ObTypeLookup {
             enum_type: py.import("enum").unwrap().getattr("Enum").unwrap().get_type_ptr() as usize,
             generator: py.import("types").unwrap().getattr("GeneratorType").unwrap().as_ptr() as usize,
             path: py.import("pathlib").unwrap().getattr("Path").unwrap().as_ptr() as usize,
+            uuid: py.import("uuid").unwrap().getattr("UUID").unwrap().get_type_ptr() as usize,
         }
     }
 
@@ -130,6 +133,7 @@ impl ObTypeLookup {
             ObType::Enum => self.enum_type == ob_type,
             ObType::Generator => self.generator == ob_type,
             ObType::Path => self.path == ob_type,
+            ObType::Uuid => self.uuid == ob_type,
             ObType::Unknown => false,
         };
 
@@ -218,6 +222,8 @@ impl ObTypeLookup {
             ObType::Generator
         } else if ob_type == self.path {
             ObType::Path
+        } else if ob_type == self.uuid {
+            ObType::Uuid
         } else {
             // this allows for subtypes of the supported class types,
             // if `ob_type` didn't match any member of self, we try again with the next base type pointer
@@ -315,6 +321,8 @@ pub enum ObType {
     Generator,
     // Path
     Path,
+    // Uuid
+    Uuid,
     // unknown type
     Unknown,
 }

src/serializers/infer.rs

@@ -128,6 +128,7 @@ combined_serializer! {
         Dataclass: super::type_serializers::dataclass::DataclassSerializer;
         Url: super::type_serializers::url::UrlSerializer;
         MultiHostUrl: super::type_serializers::url::MultiHostUrlSerializer;
+        Uuid: super::type_serializers::uuid::UuidSerializer;
         Any: super::type_serializers::any::AnySerializer;
         Format: super::type_serializers::format::FormatSerializer;
         ToString: super::type_serializers::format::ToStringSerializer;

src/serializers/ob_type.rs

@@ -22,6 +22,7 @@ pub mod tuple;
 pub mod typed_dict;
 pub mod union;
 pub mod url;
+pub mod uuid;
 pub mod with_default;
 
 pub(self) use super::computed_fields::ComputedFields;

src/serializers/shared.rs

@@ -34,6 +34,7 @@ impl TypeSerializer for StrSerializer {
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
+        dbg!("to python");
         match extra.ob_type_lookup.is_type(value, ObType::Str) {
             IsType::Exact => Ok(value.into_py(py)),
             IsType::Subclass => match extra.mode {

src/serializers/type_serializers/mod.rs

@@ -0,0 +1,84 @@
+use std::borrow::Cow;
+
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyString};
+
+use crate::definitions::DefinitionsBuilder;
+
+use super::{
+    infer_json_key, infer_serialize, infer_to_python, py_err_se_err, BuildSerializer, CombinedSerializer, Extra,
+    IsType, ObType, SerMode, TypeSerializer,
+};
+
+#[derive(Debug, Clone)]
+pub struct UuidSerializer;
+
+impl BuildSerializer for UuidSerializer {
+    const EXPECTED_TYPE: &'static str = "uuid";
+
+    fn build(
+        _schema: &PyDict,
+        _config: Option<&PyDict>,
+        _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+    ) -> PyResult<CombinedSerializer> {
+        Ok(Self {}.into())
+    }
+}
+
+impl TypeSerializer for UuidSerializer {
+    fn to_python(
+        &self,
+        value: &PyAny,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        let py = value.py();
+        match extra.ob_type_lookup.is_type(value, ObType::Str) {
+            IsType::Exact => Ok(value.into_py(py)),
+            IsType::Subclass => match extra.mode {
+                SerMode::Json => Ok(value.extract::<&str>()?.into_py(py)),
+                _ => Ok(value.into_py(py)),
+            },
+            IsType::False => {
+                extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
+                infer_to_python(value, include, exclude, extra)
+            }
+        }
+    }
+
+    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+        if let Ok(py_str) = key.downcast::<PyString>() {
+            Ok(py_str.to_string_lossy())
+        } else {
+            extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
+            infer_json_key(key, extra)
+        }
+    }
+
+    fn serde_serialize<S: serde::ser::Serializer>(
+        &self,
+        value: &PyAny,
+        serializer: S,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        match value.downcast::<PyString>() {
+            Ok(py_str) => serialize_py_str(py_str, serializer),
+            Err(_) => {
+                extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
+                infer_serialize(value, serializer, include, exclude, extra)
+            }
+        }
+    }
+
+    fn get_name(&self) -> &str {
+        Self::EXPECTED_TYPE
+    }
+}
+
+pub fn serialize_py_str<S: serde::ser::Serializer>(py_str: &PyString, serializer: S) -> Result<S::Ok, S::Error> {
+    let s = py_str.to_str().map_err(py_err_se_err)?;
+    serializer.serialize_str(s)
+}