add uuid serializer

Author: martinabeleda

src/input/input_abstract.rs

@@ -10,7 +10,6 @@ use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherString};
 use super::{GenericArguments, GenericCollection, GenericIterator, GenericMapping, JsonInput};
 
-#[derive(Debug)]
 pub enum InputType {
     Python,
     Json,

src/serializers/shared.rs

@@ -125,6 +125,7 @@ combined_serializer! {
         Model: super::type_serializers::model::ModelSerializer;
         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/type_serializers/mod.rs

@@ -21,6 +21,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/type_serializers/uuid.rs

@@ -0,0 +1,80 @@
+use std::borrow::Cow;
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+use crate::definitions::DefinitionsBuilder;
+use crate::uuid::PyUuid;
+
+use super::{
+    infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, 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 value.extract::<PyUuid>() {
+            Ok(py_uuid) => match extra.mode {
+                SerMode::Json => Ok(py_uuid.__str__().into_py(py)),
+                _ => Ok(value.into_py(py)),
+            },
+            Err(_) => {
+                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>> {
+        match key.extract::<PyUuid>() {
+            Ok(py_uuid) => Ok(Cow::Owned(py_uuid.__str__())),
+            Err(_) => {
+                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.extract::<PyUuid>() {
+            Ok(py_uuid) => serializer.serialize_str(&py_uuid.__str__()),
+            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
+    }
+}

src/uuid.rs

@@ -85,7 +85,7 @@ impl PyUuid {
     }
 
     fn __bool__(&self) -> bool {
-        true // an empty string is not a valid UUID
+        true
     }
 
     pub fn __deepcopy__(&self, py: Python, _memo: &PyDict) -> Py<PyAny> {

tests/test_schema_functions.py

@@ -219,6 +219,7 @@ def args(*args, **kwargs):
     ),
     (core_schema.json_schema, args({'type': 'int'}), {'type': 'json', 'schema': {'type': 'int'}}),
     (core_schema.url_schema, args(), {'type': 'url'}),
+    (core_schema.uuid_schema, args(), {'type': 'uuid'}),
     (core_schema.multi_host_url_schema, args(), {'type': 'multi-host-url'}),
     (
         core_schema.lax_or_strict_schema,
@@ -279,9 +280,6 @@ def test_all_schema_functions_used():
     types_used.remove('typed-dict-field')
     types_used.remove('model-field')
 
-    # TODO(martinabeleda): use this schema
-    all_types.remove('uuid')
-
     assert all_types == types_used