Merge branch 'main' into union-ser-fixes

Author: sydney-runkle

src/serializers/computed_fields.rs

@@ -14,7 +14,7 @@ use crate::tools::SchemaDict;
 use super::errors::py_err_se_err;
 use super::Extra;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub(super) struct ComputedFields(Vec<ComputedField>);
 
 impl ComputedFields {
@@ -109,7 +109,7 @@ impl ComputedFields {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct ComputedField {
     property_name: String,
     property_name_py: Py<PyString>,

src/serializers/fields.rs

@@ -20,7 +20,7 @@ use super::shared::PydanticSerializer;
 use super::shared::{CombinedSerializer, TypeSerializer};
 
 /// representation of a field for serialization
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub(super) struct SerField {
     pub key_py: Py<PyString>,
     pub alias: Option<String>,
@@ -93,7 +93,7 @@ pub(super) enum FieldsMode {
 }
 
 /// General purpose serializer for fields - used by dataclasses, models and typed_dicts
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct GeneralFieldsSerializer {
     fields: AHashMap<String, SerField>,
     computed_fields: Option<ComputedFields>,

src/serializers/infer.rs

@@ -266,7 +266,7 @@ pub(crate) fn infer_to_python_known(
             ObType::Generator => {
                 let iter = super::type_serializers::generator::SerializationIterator::new(
                     value.downcast()?,
-                    super::type_serializers::any::AnySerializer.into(),
+                    super::type_serializers::any::AnySerializer::get(),
                     SchemaFilter::default(),
                     include,
                     exclude,

src/serializers/shared.rs

@@ -40,7 +40,7 @@ macro_rules! combined_serializer {
         find_only: {$($builder:path;)*}
         both: {$($b_key:ident: $b_serializer:path;)*}
     ) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug)]
         #[enum_dispatch]
         pub enum CombinedSerializer {
             $($e_key($e_serializer),)*
@@ -257,7 +257,7 @@ impl PyGcTraverse for CombinedSerializer {
 }
 
 #[enum_dispatch(CombinedSerializer)]
-pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
+pub(crate) trait TypeSerializer: Send + Sync + Debug {
     fn to_python(
         &self,
         value: &Bound<'_, PyAny>,

src/serializers/type_serializers/any.rs

@@ -1,4 +1,7 @@
-use std::borrow::Cow;
+use std::{
+    borrow::Cow,
+    sync::{Arc, OnceLock},
+};
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
@@ -14,6 +17,13 @@ use super::{
 #[derive(Debug, Clone, Default)]
 pub struct AnySerializer;
 
+impl AnySerializer {
+    pub fn get() -> &'static Arc<CombinedSerializer> {
+        static ANY_SERIALIZER: OnceLock<Arc<CombinedSerializer>> = OnceLock::new();
+        ANY_SERIALIZER.get_or_init(|| Arc::new(Self.into()))
+    }
+}
+
 impl BuildSerializer for AnySerializer {
     const EXPECTED_TYPE: &'static str = "any";
 

src/serializers/type_serializers/bytes.rs

@@ -11,7 +11,7 @@ use super::{
     TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct BytesSerializer {
     bytes_mode: BytesMode,
 }

src/serializers/type_serializers/dataclass.rs

@@ -61,7 +61,7 @@ impl BuildSerializer for DataclassArgsBuilder {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DataclassSerializer {
     class: Py<PyType>,
     serializer: Box<CombinedSerializer>,

src/serializers/type_serializers/datetime_etc.rs

@@ -38,7 +38,7 @@ fn downcast_date_reject_datetime<'a, 'py>(py_date: &'a Bound<'py, PyAny>) -> PyR
 
 macro_rules! build_serializer {
     ($struct_name:ident, $expected_type:literal, $downcast:path, $convert_func:ident $(, $json_check_func:ident)?) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug)]
         pub struct $struct_name;
 
         impl BuildSerializer for $struct_name {

src/serializers/type_serializers/decimal.rs

@@ -11,7 +11,7 @@ use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DecimalSerializer {}
 
 impl BuildSerializer for DecimalSerializer {

src/serializers/type_serializers/definitions.rs

@@ -12,7 +12,7 @@ use crate::tools::SchemaDict;
 
 use super::{py_err_se_err, BuildSerializer, CombinedSerializer, Extra, TypeSerializer};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DefinitionsSerializerBuilder;
 
 impl BuildSerializer for DefinitionsSerializerBuilder {

src/serializers/type_serializers/dict.rs

@@ -15,7 +15,7 @@ use super::{
     SchemaFilter, SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DictSerializer {
     key_serializer: Box<CombinedSerializer>,
     value_serializer: Box<CombinedSerializer>,

src/serializers/type_serializers/enum_.rs

@@ -15,7 +15,7 @@ use super::simple::IntSerializer;
 use super::string::StrSerializer;
 use super::{BuildSerializer, CombinedSerializer, Extra, TypeSerializer};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct EnumSerializer {
     class: Py<PyType>,
     serializer: Option<Box<CombinedSerializer>>,

src/serializers/type_serializers/float.rs

@@ -12,10 +12,11 @@ use crate::tools::SchemaDict;
 use super::simple::to_str_json_key;
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, IsType, ObType,
-    SerMode, TypeSerializer,
+    SerCheck, SerMode, TypeSerializer,
 };
+use crate::serializers::errors::PydanticSerializationUnexpectedValue;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FloatSerializer {
     inf_nan_mode: InfNanMode,
 }
@@ -73,12 +74,15 @@ impl TypeSerializer for FloatSerializer {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::Float) {
             IsType::Exact => Ok(value.into_py(py)),
-            IsType::Subclass => match extra.mode {
-                SerMode::Json => {
-                    let rust_value = value.extract::<f64>()?;
-                    Ok(rust_value.to_object(py))
-                }
-                _ => infer_to_python(value, include, exclude, extra),
+            IsType::Subclass => match extra.check {
+                SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
+                SerCheck::Lax | SerCheck::None => match extra.mode {
+                    SerMode::Json => {
+                        let rust_value = value.extract::<f64>()?;
+                        Ok(rust_value.to_object(py))
+                    }
+                    _ => infer_to_python(value, include, exclude, extra),
+                },
             },
             IsType::False => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;

src/serializers/type_serializers/format.rs

@@ -53,7 +53,7 @@ impl WhenUsed {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FormatSerializer {
     format_func: PyObject,
     formatting_string: Py<PyString>,
@@ -161,7 +161,7 @@ impl TypeSerializer for FormatSerializer {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ToStringSerializer {
     when_used: WhenUsed,
 }

src/serializers/type_serializers/function.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::sync::Arc;
 
 use pyo3::exceptions::{PyAttributeError, PyRecursionError, PyRuntimeError};
 use pyo3::gc::PyVisit;
@@ -71,7 +72,7 @@ impl BuildSerializer for FunctionPlainSerializerBuilder {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FunctionPlainSerializer {
     func: PyObject,
     name: String,
@@ -314,13 +315,13 @@ impl BuildSerializer for FunctionWrapSerializerBuilder {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FunctionWrapSerializer {
-    serializer: Box<CombinedSerializer>,
+    serializer: Arc<CombinedSerializer>,
     func: PyObject,
     name: String,
     function_name: String,
-    return_serializer: Box<CombinedSerializer>,
+    return_serializer: Arc<CombinedSerializer>,
     when_used: WhenUsed,
     is_field_serializer: bool,
     info_arg: bool,
@@ -358,11 +359,11 @@ impl BuildSerializer for FunctionWrapSerializer {
 
         let name = format!("wrap_function[{function_name}, {}]", serializer.get_name());
         Ok(Self {
-            serializer: Box::new(serializer),
+            serializer: Arc::new(serializer),
             func: function.into_py(py),
             function_name,
             name,
-            return_serializer: Box::new(return_serializer),
+            return_serializer: Arc::new(return_serializer),
             when_used: WhenUsed::new(&ser_schema, WhenUsed::Always)?,
             is_field_serializer,
             info_arg,
@@ -419,10 +420,9 @@ impl_py_gc_traverse!(FunctionWrapSerializer {
 function_type_serializer!(FunctionWrapSerializer);
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct SerializationCallable {
-    serializer: CombinedSerializer,
+    serializer: Arc<CombinedSerializer>,
     extra_owned: ExtraOwned,
     filter: AnyFilter,
     include: Option<PyObject>,
@@ -432,7 +432,7 @@ pub(crate) struct SerializationCallable {
 impl SerializationCallable {
     pub fn new(
         py: Python,
-        serializer: &CombinedSerializer,
+        serializer: &Arc<CombinedSerializer>,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,

src/serializers/type_serializers/generator.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::sync::Arc;
 
 use pyo3::gc::PyVisit;
 use pyo3::intern;
@@ -17,9 +18,9 @@ use super::{
     PydanticSerializer, SchemaFilter, SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct GeneratorSerializer {
-    item_serializer: Box<CombinedSerializer>,
+    item_serializer: Arc<CombinedSerializer>,
     filter: SchemaFilter<usize>,
 }
 
@@ -37,7 +38,7 @@ impl BuildSerializer for GeneratorSerializer {
             None => AnySerializer::build(schema, config, definitions)?,
         };
         Ok(Self {
-            item_serializer: Box::new(item_serializer),
+            item_serializer: Arc::new(item_serializer),
             filter: SchemaFilter::from_schema(schema)?,
         }
         .into())
@@ -82,7 +83,7 @@ impl TypeSerializer for GeneratorSerializer {
                     _ => {
                         let iter = SerializationIterator::new(
                             py_iter,
-                            self.item_serializer.as_ref().clone(),
+                            &self.item_serializer,
                             self.filter.clone(),
                             include,
                             exclude,
@@ -152,13 +153,12 @@ impl TypeSerializer for GeneratorSerializer {
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct SerializationIterator {
     iterator: Py<PyIterator>,
     #[pyo3(get)]
     index: usize,
-    item_serializer: CombinedSerializer,
+    item_serializer: Arc<CombinedSerializer>,
     extra_owned: ExtraOwned,
     filter: SchemaFilter<usize>,
     include: Option<PyObject>,
@@ -168,7 +168,7 @@ pub(crate) struct SerializationIterator {
 impl SerializationIterator {
     pub fn new(
         py_iter: &Bound<'_, PyIterator>,
-        item_serializer: CombinedSerializer,
+        item_serializer: &Arc<CombinedSerializer>,
         filter: SchemaFilter<usize>,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
@@ -177,7 +177,7 @@ impl SerializationIterator {
         Self {
             iterator: py_iter.clone().into(),
             index: 0,
-            item_serializer,
+            item_serializer: item_serializer.clone(),
             extra_owned: ExtraOwned::new(extra),
             filter,
             include: include.map(|v| v.clone().into()),

src/serializers/type_serializers/json.rs

@@ -16,7 +16,7 @@ use super::{
     TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct JsonSerializer {
     serializer: Box<CombinedSerializer>,
 }

src/serializers/type_serializers/json_or_python.rs

@@ -8,7 +8,7 @@ use super::{BuildSerializer, CombinedSerializer, Extra, TypeSerializer};
 use crate::definitions::DefinitionsBuilder;
 use crate::tools::SchemaDict;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct JsonOrPythonSerializer {
     json: Box<CombinedSerializer>,
     python: Box<CombinedSerializer>,

src/serializers/type_serializers/list.rs

@@ -15,7 +15,7 @@ use super::{
     SchemaFilter, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ListSerializer {
     item_serializer: Box<CombinedSerializer>,
     filter: SchemaFilter<usize>,

src/serializers/type_serializers/literal.rs

@@ -16,7 +16,7 @@ use super::{
     SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct LiteralSerializer {
     expected_int: AHashSet<i64>,
     expected_str: AHashSet<String>,

src/serializers/type_serializers/model.rs

@@ -72,7 +72,7 @@ impl BuildSerializer for ModelFieldsBuilder {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ModelSerializer {
     class: Py<PyType>,
     serializer: Box<CombinedSerializer>,

src/serializers/type_serializers/nullable.rs

@@ -9,7 +9,7 @@ use crate::tools::SchemaDict;
 
 use super::{infer_json_key_known, BuildSerializer, CombinedSerializer, Extra, IsType, ObType, TypeSerializer};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct NullableSerializer {
     serializer: Box<CombinedSerializer>,
 }