Merge branch 'main' of github.com:pydantic/pydantic-core into fix-12273-dict

Author: CloseChoice

python/pydantic_core/core_schema.py

@@ -1939,6 +1939,7 @@ class DictSchema(TypedDict, total=False):
     values_schema: CoreSchema  # default: AnySchema
     min_length: int
     max_length: int
+    fail_fast: bool
     strict: bool
     ref: str
     metadata: dict[str, Any]
@@ -1951,6 +1952,7 @@ def dict_schema(
     *,
     min_length: int | None = None,
     max_length: int | None = None,
+    fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
@@ -1974,6 +1976,7 @@ def dict_schema(
         values_schema: The value must be a dict with values that match this schema
         min_length: The value must be a dict with at least this many items
         max_length: The value must be a dict with at most this many items
+        fail_fast: Stop validation on the first error
         strict: Whether the keys and values should be validated with strict mode
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
@@ -1985,6 +1988,7 @@ def dict_schema(
         values_schema=values_schema,
         min_length=min_length,
         max_length=max_length,
+        fail_fast=fail_fast,
         strict=strict,
         ref=ref,
         metadata=metadata,

src/build_tools.rs

@@ -1,6 +1,8 @@
 use std::error::Error;
 use std::fmt;
+use std::ops::Deref;
 use std::str::FromStr;
+use std::sync::OnceLock;
 
 use pyo3::exceptions::PyException;
 use pyo3::prelude::*;
@@ -217,3 +219,28 @@ impl FromStr for ExtraBehavior {
         }
     }
 }
+
+/// A lazily-initialized value.
+///
+/// This is a basic replacement for `LazyLock` which is available only in Rust 1.80+.
+pub struct LazyLock<T> {
+    init: fn() -> T,
+    value: OnceLock<T>,
+}
+
+impl<T> Deref for LazyLock<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value.get_or_init(self.init)
+    }
+}
+
+impl<T> LazyLock<T> {
+    pub const fn new(init: fn() -> T) -> Self {
+        Self {
+            init,
+            value: OnceLock::new(),
+        }
+    }
+}

src/input/input_abstract.rs

@@ -85,7 +85,7 @@ pub trait Input<'py>: fmt::Debug {
 
     fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<Self::Arguments<'a>>;
 
-    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValMatch<EitherString<'_>>;
+    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValMatch<EitherString<'_, 'py>>;
 
     fn validate_bytes<'a>(&'a self, strict: bool, mode: ValBytesMode) -> ValMatch<EitherBytes<'a, 'py>>;
 
@@ -103,7 +103,7 @@ pub trait Input<'py>: fmt::Debug {
 
     /// Extract a String from the input, only allowing exact
     /// matches for a String (no subclasses)
-    fn exact_str(&self) -> ValResult<EitherString<'_>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_, 'py>> {
         self.validate_str(true, false).and_then(|val_match| {
             val_match
                 .require_exact()

src/input/input_json.rs

@@ -107,7 +107,11 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>> {
+    fn validate_str(
+        &self,
+        strict: bool,
+        coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'_, 'py>>> {
         // Justification for `strict` instead of `exact` is that in JSON strings can also
         // represent other datatypes such as UUID and date more exactly, so string is a
         // converting input
@@ -163,7 +167,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    fn exact_str(&self) -> ValResult<EitherString<'_>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_, 'py>> {
         match self {
             JsonValue::Str(s) => Ok(s.as_ref().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
@@ -414,7 +418,7 @@ impl<'py> Input<'py> for str {
         &self,
         _strict: bool,
         _coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'_>>> {
+    ) -> ValResult<ValidationMatch<EitherString<'_, 'py>>> {
         // Justification for `strict` instead of `exact` is that in JSON strings can also
         // represent other datatypes such as UUID and date more exactly, so string is a
         // converting input

src/input/input_python.rs

@@ -192,7 +192,11 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>> {
+    fn validate_str(
+        &self,
+        strict: bool,
+        coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'_, 'py>>> {
         if let Ok(py_str) = self.downcast_exact::<PyString>() {
             return Ok(ValidationMatch::exact(py_str.clone().into()));
         } else if let Ok(py_str) = self.downcast::<PyString>() {
@@ -339,7 +343,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    fn exact_str(&self) -> ValResult<EitherString<'_>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_, 'py>> {
         if let Ok(py_str) = self.downcast_exact() {
             Ok(EitherString::Py(py_str.clone()))
         } else {

src/input/input_string.rs

@@ -105,7 +105,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         &self,
         _strict: bool,
         _coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'_>>> {
+    ) -> ValResult<ValidationMatch<EitherString<'_, 'py>>> {
         match self {
             Self::String(s) => Ok(ValidationMatch::strict(s.clone().into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::StringType, self)),

src/input/return_enums.rs

@@ -468,41 +468,41 @@ impl<'data> GenericJsonIterator<'data> {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum EitherString<'a> {
+pub enum EitherString<'a, 'py> {
     Cow(Cow<'a, str>),
-    Py(Bound<'a, PyString>),
+    Py(Bound<'py, PyString>),
 }
 
-impl<'a> EitherString<'a> {
+impl<'py> EitherString<'_, 'py> {
     pub fn as_cow(&self) -> ValResult<Cow<'_, str>> {
         match self {
-            Self::Cow(data) => Ok(data.clone()),
+            Self::Cow(data) => Ok(Cow::Borrowed(data)),
             Self::Py(py_str) => Ok(Cow::Borrowed(py_string_str(py_str)?)),
         }
     }
 
-    pub fn as_py_string(&'a self, py: Python<'a>, cache_str: StringCacheMode) -> Bound<'a, PyString> {
+    pub fn as_py_string(&self, py: Python<'py>, cache_str: StringCacheMode) -> Bound<'py, PyString> {
         match self {
             Self::Cow(cow) => new_py_string(py, cow.as_ref(), cache_str),
             Self::Py(py_string) => py_string.clone(),
         }
     }
 }
 
-impl<'a> From<&'a str> for EitherString<'a> {
+impl<'a> From<&'a str> for EitherString<'a, '_> {
     fn from(data: &'a str) -> Self {
         Self::Cow(Cow::Borrowed(data))
     }
 }
 
-impl From<String> for EitherString<'_> {
+impl From<String> for EitherString<'_, '_> {
     fn from(data: String) -> Self {
         Self::Cow(Cow::Owned(data))
     }
 }
 
-impl<'a> From<Bound<'a, PyString>> for EitherString<'a> {
-    fn from(date: Bound<'a, PyString>) -> Self {
+impl<'py> From<Bound<'py, PyString>> for EitherString<'_, 'py> {
+    fn from(date: Bound<'py, PyString>) -> Self {
         Self::Py(date)
     }
 }

src/serializers/computed_fields.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
@@ -21,7 +23,7 @@ impl ComputedFields {
     pub fn new(
         schema: &Bound<'_, PyDict>,
         config: Option<&Bound<'_, PyDict>>,
-        definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+        definitions: &mut DefinitionsBuilder<Arc<CombinedSerializer>>,
     ) -> PyResult<Option<Self>> {
         let py = schema.py();
         if let Some(computed_fields) = schema.get_as::<Bound<'_, PyList>>(intern!(py, "computed_fields"))? {
@@ -182,7 +184,7 @@ struct ComputedFieldToSerialize<'a, 'py> {
 struct ComputedField {
     property_name: String,
     property_name_py: Py<PyString>,
-    serializer: CombinedSerializer,
+    serializer: Arc<CombinedSerializer>,
     alias: String,
     alias_py: Py<PyString>,
     serialize_by_alias: Option<bool>,
@@ -192,7 +194,7 @@ impl ComputedField {
     pub fn new(
         schema: &Bound<'_, PyAny>,
         config: Option<&Bound<'_, PyDict>>,
-        definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+        definitions: &mut DefinitionsBuilder<Arc<CombinedSerializer>>,
     ) -> PyResult<Self> {
         let py = schema.py();
         let schema: &Bound<'_, PyDict> = schema.downcast()?;

src/serializers/fields.rs

@@ -1,4 +1,5 @@
 use std::borrow::Cow;
+use std::sync::Arc;
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
@@ -25,7 +26,7 @@ pub(super) struct SerField {
     pub alias: Option<String>,
     pub alias_py: Option<Py<PyString>>,
     // None serializer means exclude
-    pub serializer: Option<CombinedSerializer>,
+    pub serializer: Option<Arc<CombinedSerializer>>,
     pub required: bool,
     pub serialize_by_alias: Option<bool>,
     pub serialization_exclude_if: Option<Py<PyAny>>,
@@ -38,7 +39,7 @@ impl SerField {
         py: Python,
         key_py: Py<PyString>,
         alias: Option<String>,
-        serializer: Option<CombinedSerializer>,
+        serializer: Option<Arc<CombinedSerializer>>,
         required: bool,
         serialize_by_alias: Option<bool>,
         serialization_exclude_if: Option<Py<PyAny>>,
@@ -113,7 +114,7 @@ pub struct GeneralFieldsSerializer {
     fields: AHashMap<String, SerField>,
     computed_fields: Option<ComputedFields>,
     mode: FieldsMode,
-    extra_serializer: Option<Box<CombinedSerializer>>,
+    extra_serializer: Option<Arc<CombinedSerializer>>,
     // isize because we look up filter via `.hash()` which returns an isize
     filter: SchemaFilter<isize>,
     required_fields: usize,
@@ -132,14 +133,14 @@ impl GeneralFieldsSerializer {
     pub(super) fn new(
         fields: AHashMap<String, SerField>,
         mode: FieldsMode,
-        extra_serializer: Option<CombinedSerializer>,
+        extra_serializer: Option<Arc<CombinedSerializer>>,
         computed_fields: Option<ComputedFields>,
     ) -> Self {
         let required_fields = fields.values().filter(|f| f.required).count();
         Self {
             fields,
             mode,
-            extra_serializer: extra_serializer.map(Box::new),
+            extra_serializer,
             filter: SchemaFilter::default(),
             computed_fields,
             required_fields,

src/serializers/mod.rs

@@ -1,5 +1,6 @@
 use std::fmt::Debug;
 use std::sync::atomic::{AtomicUsize, Ordering};
+use std::sync::Arc;
 
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict, PyTuple, PyType};
@@ -39,8 +40,8 @@ pub enum WarningsArg {
 #[pyclass(module = "pydantic_core._pydantic_core", frozen)]
 #[derive(Debug)]
 pub struct SchemaSerializer {
-    serializer: CombinedSerializer,
-    definitions: Definitions<CombinedSerializer>,
+    serializer: Arc<CombinedSerializer>,
+    definitions: Definitions<Arc<CombinedSerializer>>,
     expected_json_size: AtomicUsize,
     config: SerializationConfig,
     // References to the Python schema and config objects are saved to enable